{"_id":"doc-en-rust-cc977dabed974d4bcbd1cb2e4f8886eb7e1f6cae7a3aa4a4ee14b49a9dba2970","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: Both asserts don't pass. Adding bound on makes it compile. We are requiring all the for closures and generators to outlive here: This is wrong and inconsistent with the logic 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. --Build using the Nightly version: 1.63.0-nightly (2022-05-24 ) <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details label T-compiler A-lifetimes A-closures A-generators claim <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nError: Parsing assign command in failed: ...'bot assign' ''... Please let know if you're having trouble with this bot."}
{"_id":"doc-en-rust-a23e3246976f07eb139e374e0803ff2e2de983d7ac4ec4cba804ec3187641873","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. --With the latest nightly, the bytemuck crate fails to compile. This was compiling yesterday and the issue seems to be traits are not imported with super::*. Please see the issue in the bytemuck repository: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: </p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nRegression in searched nightlies: from nightly-2023-06-10 to nightly-2023-06-20 regressed nightly: nightly-2023-06-20 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: cc\n<details<summaryi made a mistake making the example, see below </summaryThis should error in coherence, but instead errors with It looks like if there is a derive macro and trait with the same name, glob imports don't resolve the trait anymore. Note that works correctly </details\nMaybe the reduced it incorrect? I found that it also throw an error for 1.70?\nhm, maybe your change simply exposed an existing bug in more cases\nI will check it later claim\nah no, I made a stupid mistake, i should have used :D, my example only got from the prelude which only contains the macro.\nThis is resolved, of course. Only tagging this with Nilstrieb's estimated priority for historical analysis later.\nNow that this fix is merged, what time tonight should we expect a new nightly release?\n0:00 according to a server somewhere. In practice, usually UTC 0:00. So it should be being cut sometime soon. Or 24 hours from now. Either one."}
{"_id":"doc-en-rust-77205d48863db45330465ccf4419b60ef659f197740f3bb7a65b2650285412b1","title":"","text":"Found via rust-icci: https://travis- The commit history of the regex crate contains on changeset that only adds a comment which in turn leads to the body of a function being moved. This results in the update of the source location pointed to by a potential overflow panic message. This message is not updated properly in incremental mode: I have not found out yet why the change is not detected. HIR fingerprinting has special treatment of operations that can trigger overflows: There must be some kind of mismatch between when HIR fingerprinting thinks that an operation can panic and when we actually emit panic messages. This is another span-related papercut cc\nFull IR files for reference:"}
{"_id":"doc-en-rust-ed2179e0830404846bb598040cc05d41169750b05e3cef96b225bd70113ace6b","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\nIs this related to ?\nNope\nOoh I misread the Typerror ice, my bad :upsidedownface:\nNo big deal, this has to do with a lock (well, refcell) being held in hir typeck, if you're curious"}
{"_id":"doc-en-rust-84fcbfe2dfb6d5a723b82e44468381e2a3da70b15ab70d0a99a9e4d0ba3092c5","title":"","text":"If you combine LTO, anything that uses alloc and debug compilation mode, the compiler fails. The minimum example to reproduce is this : With this : To reproduce, run (or just use ): You should see this error: The above error does not reproduce for other compiler versions or options, all of the below work: I found reporting something similar, but for them is throwing the error, so I opened a new issue instead. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nInitial reduction for :\nFiled\nIn , dblaikie suggests that ought to separate the type-method declaration from the function definition, and I think I have that working. It passes the reproducer here, at least... claim"}
{"_id":"doc-en-rust-91b369aeb426347d6b8231fdba7eb7997f427653713dc431cf27726b86223550","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 nightly release , we've had build failures for () with message when lto is enabled. If I disable LTO, the build succeeds and the test passes. There are many similar tests which do currently build and run successfully with this version, it is only one specific test we have which is causing the issue. You can reproduce the issue if you build the test in release mode: I haven't been able to work out what actually causes this, and it seems to require a reasonable amount of code before the issue gets triggered. <!-- Provide the most recent version this worked on, for example: It most recently worked on: Rust 1.47 --It most recently worked on: Rust nightly 2023-03-23 <!-- Provide the version you are using that has the regression. --: The error message isn't particularly helpful here, but here is the full output from our github action: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nhere probably more info on how to reproduce could help. If I read the , the test alone compiles but it fails when enabling the flag, thus the label. label E-needs-mcve\nWG-prioritization assigning priority (). label -I-prioritize +P-medium\nProbably related to the LLVM upgrade, but I was unable to reduce this to a pure LLVM reproducer.\nWe just got this error building Firefox on Fedora 38, with Rust 1.69.0 and LLVM 16.0.1:\nSee /\nI'll try a build with that patch. One thing to note though, regarding: The Firefox build got this message on aarch64, ppc64le, and x86_64. (Only s390x succeeded.)\nD147620 worked locally for me, building LLVM 16 with that patch and then Firefox built fine. But it looks like that review is not settled yet."}
{"_id":"doc-en-rust-2f6398cbe60188fee4a34613e0d5216323ec81df127602adfa2714b3821bcf39","title":"","text":"Whether the ultimate fix is in LLVM or rustc, I hope we can get that into beta for the 1.70.0 release.\nI have a patch for rustc that passes the test case in -- I'll try with Firefox later today. claim"}
{"_id":"doc-en-rust-592cb108c3b10b7169263c448aa003f01706e3f97845e748be93bac138b7415d","title":"","text":"I encounter an ICE: with rustc 1.41.0-nightly ( 2019-11-29) running on x8664-apple-darwin when compiling The same code does not ICE when using nightly-2019-11-27-x8664-apple-darwin Sorry, I haven't taken the time to make a minimal reproduction example.\nCan you post the ICE message and backtrace?\nCertainly! Although it is not the best stacktrace I have ever seen. Backtrace:\nBacktrace:\nmodify labels: A-mir\nI think I have a clue here: First the code: The problem seems to be a partial move of together with async together with a generic type (if we replace by for example, rust will complain as well and no ICE). If we remove the rust will complain: modify labels: +A-async-await -E-needs-mcve +E-needs-bisection\nRegression in cc modify labels: -E-needs-bisection\ntriage: has PR. P-high, removing nomination."}
{"_id":"doc-en-rust-ef0d3049cd6bd106295aa0ab14267778e42b1040435938558e229122e585f8ca","title":"","text":"The support for ARMv6 architecture was broken somewhere between ...: compiles file while produces binary that crashes with . More specifically, this is a binary cross-compiled from for arch, linked with a . The hardware is part of Raspberry Pi Zero rev. 1.1, the processor information is as follows:\nPresumably due to LLVM update. Can you determine what the illegal instruction is? (E.g. via gdb and .)\ndid you try compiling code on your raspberry pi 0 ? this might be issue with gcc cross compiler (code generator part)l/linker rather than Rust\nLooks like even compilation directly on RPi0 is broken as the compiler/cargo crashes: Running under gdb: I'm not sure if this helpful at all, I can send (e-mail) you the coredump or do anything else you need, unfortunately I have basically no experience debugging low-level ASM issues.\nThe problematic instruction is , which vfp2 and dpvfp. The target builds with . There were some in LLVM 9 around the sp/dp handling on ARM ( became ), possibly we flipped a default there...\nAccording to the ARM1176JZF-S Technical Reference Manual (which is the CPU used in Raspberry Pi Zero) it contains a VFP11 coprocessor (VFP2 implementation with full support for single-precision and double-precision math operations). Maybe VFP11 is somehow slightly different from what LLVM assumes? ARM refs: VFP11 VectorFloating-point Coprocessor Technical Reference Manual for ARM1136JF-S\nThanks for the references. So both vfp2 and fp64 should be supported. Something I missed before is that the instruction uses the register, while the VFP11 coprocessor only has 16 double-precision registers. To target this CPU needs to be to the target features. It looks like the corresponding does disable . Possibly the default flipped here, in which case we should just add to all the older ARM targets.\nThis issue might be related to this one - libc's CI is broken since the LLVM upgrade.\nThis is probably caused by EDIT: Ah nevermind, someone found this already\nReopening until there is confirmation that this is fixed...\nHi with the recent 1.38.0-nightly ( 2019-07-26) both local toolchain / cargo and the cross-compiled binary seem to work. Thanks.\nGreat, closing as fixed"}
{"_id":"doc-en-rust-ff644e4863f7570a4d185718c990b27b51251b5af494f57f2fcef0eadd3eed5a","title":"","text":"According to and in , this feature-gate should not be used. It appears that earlier error checking in the compiler prevents it from ever mattering anyway."}
{"_id":"doc-en-rust-50c7092c496556fd83fc85aaaf3beb00c9b3629ddec4e33ab2c2f0ea6decbb91","title":"","text":"From Given the following Rust code with in-line annotations of the expected behaviour: On: does not seem to be able to generate feature requirement labels on types in private modules () that are publicly reexported (). The labels do not show up on the module overview nor page, but do propagate into items like functions for the given type. This renders the type without any feature requirement, neither in the module overview: ! Nor on the page: ! Note that the label is propagated onto (does not have an explicit ), at least understood that! It is supposed to render the feature requirement for like , both in the module overview above as on the page: ! It seems tricky to combine feature requirements on the and reexport. In the case above they are the same, but what if: The type is only publicly available when and are specified. Specifying is fine but makes the contents of unreachable through the current module, specifying only should result in a \"module not found\" error. CC\nThis also affects re-exports of entire crates. Unfortunately there the fix is not clear at all, since the \"parent\" crate is obviously not guaranteed to have the same features as the crate being re-exported.\nWithin the same crate as well; it's not about the features that are enabled (though it is relevant which are available) but about the combined restrictions that are placed on the definition and reexport. Simplest I can think of is a union of all features (but gets complicated quick when inversions and vs is used) and later perhaps simplifying based on feature relations (if implies there is no need to display as requirement, if either definition or reexport requires ). That's necessary to cleanly solve crate reexports, since you effectively want to ensure that the top-level crate feature implies feature and hide it. If the whole resolver is made smart enough (perhaps this already exists, I'm not too familiar with Cargo) it could even throw warnings when there exist feature combinations that would lead to a compiler error (ie. explicitly reexporting a symbol that is not available for a certain set of features).\nI wonder if this is just an ordering issue of the passes: The private modules have disappeared by the point where we pass all the data down so we don't see them."}
{"_id":"doc-en-rust-0600c28941e9e62aa58fa4a6908002601086eeaf89e39eb247ef1766d3b4621f","title":"","text":"Thanks for the suggestion - I moved before and (I've never built rustc/rustdoc from source, pleasantly surprised that only took just under 7min on a ThreadRipper :partyingface:) but it doesn't change anything to the generated output unfortunately :(\nI observe this on public items as well: Does not show the badge at re-exports.\nSo from the following code: is stripped and then inlined. The stripped version contains all the correct information but the inlined one doesn't. Checking what's the best course here: either cloning the stripped item or propagating when inlining."}
{"_id":"doc-en-rust-3091f83ae5732473272c082bd2ea71be2cb5a389efe9e4f45dabfb498e4e35e4","title":"","text":"The .exe installer tries to install to \"C:Program Files (x86)Rust\", even though it's the 64-bit version. It then fails to create the destination directory due to a permission error. The .msi installer correctly defaults to \"C:Program FilesRust <channel<version\", and has no problems with permissions, I would expect the .exe installer to have the same behaviour.\nRust should install to , just like Ant, Python, and many others. is the place for developer tools that have a known folder. is badly named (compare to ), poorly suited for command line tools, and clutters the already hideous PATH more than .\n/cc\nNeither Ant nor Python install to C:tools by default, and searching I can't find any reference to C:tools even being a thing? Both Python and Ant install to C:Python<Versionand C:ant, which is incredibly annoying, so please don't do that!\nI might be mistaken, but installing both through stuck them in for me. I'd recommend anyone with a machine running Vista or later use chocolatey. And there's a trend in chocolatey to have packages extract to when they aren't self-contained enough for .\nFor an OS without much filesystem hierarchy, is a decent place for developer and command-line packages, similar to on some unices. But I'd much rather see a that actually obeyed chocolatey's conventions and extracted an archive to , with no installer/registry involvement. But Rust only and installers for windows. : And all packages that do this reduce PATH clutter, since chocolatey symlinks their executables into .\nThe idea was to deprecate the .exe installer once .msi is known to be working satisfactory.\nCan we have a zip release too, that contains Rust and Cargo like the others? Linux and OS X have an archive release. Those are preferred in chocolatey because they don't involve the registry or any other Windows components.\nWe do produce tarballs for windows.\nSeems like we should probably just stop producing the .exe's. That fix would go in\nI don't see a cargo+rustc nightly tarball for windows, although I do see ones for linux and osx.\ntriage: We do not link to the .exe installer anymore, but we still produce them."}
{"_id":"doc-en-rust-4eb01b77959888d1a4348ee84953b3352a11067b0e43c11213286b952d55c3f3","title":"","text":"I don't have access to windows at the moment to check if this bug has been resolved, but it's been a long time...\nGrabbing the Windows download link from and swapping the for yields a functional link to the , which is nice. Testing on win7-x64, the MSI extracts with lessmsi, but the directory structure is somewhat unusual so there's no one-liner to get the Rust folder out. The best I came up with was: This yields a Rust install rooted at . However now that exists, multiple targets aren't really an issue anymore. Someone should make a Chocolatey package for\nCan someone with access to Windows check what happens here today?\nThe latest version installs to instead, which works, but is a terrible default.\nTriage: ! This seems... fine. I'm not sure if this should stay open or not; I'll let the relevant team (infra? compiler?) decide."}
{"_id":"doc-en-rust-4a2a3ca0578e56aa495d8a238a4a39754613458b174a8b87ffbebf00f635a35a","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 first check the RHS, before suggest adding . It should also avoid suggesting when code is invalid. Thanks. Something like this should also not suggest adding : cc <!-- 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 --\nI'm not convinced the second example should be something we need to fix, but the first example should be very easy to fix.\nclaim"}
{"_id":"doc-en-rust-7d6520bf289243098b8ae67f70af3352367a7ea68e71104ee3b573dec3aed45d","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.\nFix is on the way at"}
{"_id":"doc-en-rust-104e5ecbd6357bfec6edea7ccea9b59d68a49fb332d83bc5fca72755842c1993","title":"","text":"I spotted this in : the result links to ' which is not a valid link. Cc\ncc -- I think these are supposed to be autoredirected in JS?\nOkay... This happens because there's more than one and the one we want is currently named . The URL escaping is fine; the -35 is the problem."}
{"_id":"doc-en-rust-e8a556184d3ee8d481a844eb181edcbf5b39ce86ed75ae52fc28a83741bad2d0","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'coerceborrowedpointer had no error'', 'thread 'rustc' panicked at 'coerceborrowedpointer had no error'' 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 --\nRegression in there are no individual builds of the commits yet tho :sweat_smile:\nI would guess cc"}
{"_id":"doc-en-rust-af4a6d734eec2405d68437928d1762b0a1450d4c9315ae958757d9bfdc6d7292","title":"","text":"This is a use-after-free that compiles with 1.74.0-nightly (2023-09-13 ): cc"}
{"_id":"doc-en-rust-cb3dbc0c517a588095eda62daa96bdfedbcaf49475de56306468c3ba5d5694f1","title":"","text":"The diagnostics (\"use of undeclared lifetime name\") are bad, but this indeed must be an error because the inner is an illegal use of the outer rather than an implicitly defined fresh lifetime.\nHm, I don't think that's quite what I'd expect: previously using in that context would be fine because there is no shadowing so to speak, that is, this compiles:\nFrom Similarly, if a fn definition is nested inside another fn definition, it is an error to mention lifetimes from that outer definition (without binding them explicitly). This is again intended for future-proofing and clarity, and is an edge case. (In the second example there's an explicit definition that shadows the previous definition for following uses, in the first example there's no second definition, only use)\nI see that this is in the RFC, but I think I more or less disagree with the reasoning given. Disallowing the use of inband lifetimes when nesting function seems arbitrary and not entirely helpful; it also makes a mechanical change from \"old\" to \"new\" more difficult because shadowing is visible only based on indent levels.\nIMO it should be an error, with a helpful note like the one you get when writing . Let's not make in-band lifetimes any more confusing than they already are.\nThe distinction is that inband lifetime's selling point is that you don't need to declare lifetimes. If we say that, and then clarify it with \"except\" then I think the feature feels incomplete. Inband lifetimes confusion does not increase with permitting this, IMO.\nThe problem is if it's allowed, then has a different meaning than This seems unfortunate and confusing. Even unergonomic if I may say so. There's no way that the distinction between and won't be missed in a quick scan of the second one. But, like, the RFC process did decide that isn't important, so whatever.\nWell, somewhat, but not really. Nothing outside of imports/definitions inherits into the inner function, unlike the impl where there is a history and multiple things which inherit (, lifetimes, generics)."}
{"_id":"doc-en-rust-1f22b06224aecd994d3e19d133edc7f3e152837884d6a163ec0313c23c6e85a5","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 expected to see this happen: Compiles successfully Instead, this happened: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: label A-coherence F-negative_impls requires-nightly T-compiler\nI'll look into it"}
{"_id":"doc-en-rust-d86f98e29e96907eb74e2979df8b01395c41a9d6fde295b825e0d20753d1bba3","title":"","text":"Take a look at the docs for : Rustdoc is making good choices for whether to wrap the declarations ! But when it wraps, it doesn't include a trailing comma on the last parameter. I think it should, because the default style guide wants a comma there. (And rustdoc should continue not putting a trailing comma when the declaration is shown as a single line.) <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim"}
{"_id":"doc-en-rust-61273a09668607a4fc6bd295552f94cd92d081baebd97db8998d5806f4b4b95d","title":"","text":"Minimal example: Error message (ran in playground): Tested on nightly as well ()\nRelated:\ntwice without checking the return value. Modify it to return and check where it is being called ether both calls have returned an (cancel one, emit the other, return ), wether only one was created (emit it, return ) or none has (return ).\nI'll fix this, thanks for the instruction!\nI would happily have a go at this, if that's ok with\nSure go for it!\nhave you had time to work on this? If not could I give it a go? :)\nI totally thought I was going to have time, but I had a crazy week at work this week. Go ahead and give it a go :) I'll find another bug to work on when I definitely have time\nIt looks like the PR to fix this was merged but has a few dangling threads. There seems to be some confusion about short-circuiting functionality and the necessity of the patch and also the error count still reads 2 rather than 1. Should a new issue be opened with those issues and this issue closed?"}
{"_id":"doc-en-rust-a7f3e9810aa82b6f33a59ff9fa989846e97e88c833b24e7a93ba56e854e1291a","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\nSeems to be the indicated function:\n.\nAssigning as discussed as part of the and removing . label -I-prioritize +P-medium\nOh this is ugly x) Reading the PR, the problem is that there are two ways to match a Box: via a box-pattern or via . But we can't know which will be used based on the type only. Current code assumes box-patterns, hence the error. The PR works because luckily all the fields of are private. If you tried pattern-matching within the module that defines , you'd get crazy results like (actually wouldn't even typecheck): We'll need to figure out a real solution when we implement generalized Deref patterns...\nin that case we should open a new ticket for that work, tagged something like or something."}
{"_id":"doc-en-rust-68c6f35e025cebcb8286b1360c5297d850ed364c3a6a9f39a1bb805bfd2fed77","title":"","text":"Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should include a note suggesting the variant with the same name (but different case):\nlabel +C-enhancement +D-newcomer-roadblock\nThis only doesn't Just Work because the Levenshtein thing is case sensitive, right? There is some special-casing for case-insensitive suggestions but afaict it only applies if the case-sensitive Levenshtein distance is also already low, which seems wrong at first glance.\nim working on this Edit: I'm not working on this anymore because I ran out of time getting past incremental compilation / llvm errors after a rebase.\nOkay, judging by , this is explicitly not supposed to work. shrug emoji Edit: Okay, maybe that test case didn't really care. The use of case-insensitive match as tie breaker for equal levenshtein distance only was introduced with afaict."}
{"_id":"doc-en-rust-d920298abf7760b787a4e565d974d50dfd740c81766d2266f3334b649deb6dc5","title":"","text":"Example: yields <details<summaryBacktrace</summary</details\ncc and\nThis has to do with late-bound regions and RPITITs. I have a fix, but it's probably not right nor is it cleaned up much. I'll put it up for scrutiny soon though.\nActually nvm, it was a silly little resolver bug.\nlabel +I-ICE +C-bug"}
{"_id":"doc-en-rust-b216d664ce4ec915380dcc20e837c9f70be9575b68c08f70e28c99ec44be2bf5","title":"","text":"I'm seeing an internal compiler error on the following input (found by ):\nReport from : regressed nightly: nightly-2020-02-07\nIt looks like caused the regression. (The error happens at but not at .) cc\nThe specific commit where the error starts happening is .\ntriage: P-high. Removing nomination. Added regression stable-to-nightly tag.\nFixed by"}
{"_id":"doc-en-rust-f082c3aef65076993535a53879294d270bf93f4b927f1d32460e08cf69cd01b2","title":"","text":"root: updns-0.0.6: v.\ntriage: P-high. Nominating for discussion.\nself-assigned for investigation in short term (as in, next two or three days). However I suspect someone from will be a better choice to investigate this.\nWe should try to bisect this\nused . Determined: searched nightlies: from nightly-2019-11-26 to nightly-2020-01-03 regressed nightly: nightly-2019-12-01 searched commits: from to  regressed commit:\nis a rollup commit of the following PR's: I'm guessing this is due to PR\nI'm still working on reducing this down to something that I could put into the playpen. However, one interesting thing I've found locally during my reduction: This version of the will signal an analogous compilation error: but if I lift the first argument out to a separate -binding (i.e. change it to use above, or the sub-expression out to a separate -binding (i.e. change the argument expression to use above), then the error goes away. I'll admit that I don't know all the details of how the fn-transformation works to support , but I strongly suspect that if this kind of local code change can make an error go away, then that represents a weakness somewhere (either in the fn-transformation, or in the borrowck).\nOkay in the details block is a standalone version suitable for the : <details</detailsand the error it generates:\nSo this does seem like somewhat clear (expected?) fallout from PR : a use of a in a generator witness will be recorded as a unsafe pointer , and then is never , but the method requires that the task you give it is . I believe we can readily update the crate in question to avoid using the in the expression under the RHS of . But I do wonder whether we can/should improve the diagnostics here to try to guide the user towards such a solution ...?\nI might have worded this too strongly, and/or over-reduced my example. In particular, its easy to move around the access to . But the borrow of may be trickier to deal with.\nI'll have a look at addressing this with another approach I considered for . If that doesn't work out then I'll have a look at the error message."}
{"_id":"doc-en-rust-94691f0b089e339036895876d4ba485cfce9f9f9db63c67b7b54f1d03aec95a5","title":"","text":"The patch linked is enough to fix the crate in question, but I'm all for finding an in-compiler solution if we can do it soundly.\nOK. I'm going to write some things up because I've changed my mind a bunch of times about how/if this can be fixed in MIR building and I don't want to keep forgetting things. Generators store values that if their value needs to be preserved across a yield. These values need to be visible for auto-traits, for example a generator may be resumed on a different thread after it yields, and so cannot be if any of theses values isn't . There are two passes that determine which values can be included in the generator: A pass that runs as part of typeck that walks the HIR to find the types of expressions and then checks for yields in the values scope (as determined by the RegionScopeTree). The types recorded here are stored in the GeneratorWitnesss type contained in the generator, which is then used for auto trait checking. This notably uses the types of expressions that HIR sees. The MIR transform that lowers the generator to a state machine. This determines the values that the generator actually stores. As a check for the compiler, we assert that any types that we capture here are included in the witness type (we don't know all auto traits, so can't check only for them). After statics no longer have a special representation in MIR. They are instead lowered to a dereference of a pointer to the given static: is lowered as if it were: Which becomes: The example above is somewhat deceptive in that the temporary that holds the pointer is used immediately after it's assigned. In this case it cannot end up in the generator since it's not live across any user code. However this isn't true in all cases, index and match expressions allow running user code while the pointer is live: In these cases MIR has to put the temporary pointer into the generator state and promptly ICEs. The obvious solution now is make type checking record the new pointer types in the generator witness in these cases. Unfortunately HIR is not a great tool for specifying \"these cases\". The methods that the region scope tree provides in HIR are either usually far too large (the \"temporary scope\") or occasionally too small (the \"enclosing scope\"). went for the sound but rather approximate approach, leaving us here."}
{"_id":"doc-en-rust-91e5d54bd966fd04797fd7e837e4c3f7030fdabf8f63f1d5015a188d7b31c733","title":"","text":"One idea might be to try changing MIR building so that the temporary is never live across user code. For example, one might change the lowering as follows However working out how to do this for in a reasonable to implement way is harder. MIR actually already contains an escape hatch for values that are in the MIR but aren't in the HIR in the form of a flag (called ) on the variable. We currently use it for drop flags and boxes created by expressions. It's unclear what exactly the difference is between is. I guess one could argue that auto traits are for layout introspection and this would be further breaking that. I think that's everything for now.\nVisiting from triage. were you planning to work on this further?\nIt's definitely tempting to take advantage of the constraints around statics to just declare these equivalent, and use the flag to get out of this. While I don't see any soundness issues around that, I also don't quite trust myself to get this right :) Can you expand on this? I'm not sure I follow.\nAnother solution that comes to mind relies on the fact that these pointers never need to be stored in a generator. They are consts, and the temporaries containing them shouldn't ever be mutated. We could add semantics for \"const temporaries\" to MIR, and never store them inside generators. The semantics would (hopefully) be simple: defined once and assigned a value that doesn't depend on any other temporaries; never mutated or borrowed mutably. We can move the statements defining them to the top of the function inside the generator transform. But that would be adding more semantics and special casing to MIR to fix a change which removed extra semantics and special casing, so I'm not sure if that's what we want :)\nThe argument is that the given the following auto trait we guarantee that if then there are no raw pointers directly stored in an instance of . If we make that guarantee then using internal in generators would not be OK. I would argue that we're not making such (or really any) guarantees with user defined auto traits.\nYeah, I don't think auto traits should expose layout implementation details of generators. And this really does seem like a pure implementation detail -- it doesn't have any bearing on what kinds of (unsafe) operations are allowed on a generator, like a self-reference would."}
{"_id":"doc-en-rust-641bec651933732cd68a3e8965aab00c430d6bc19c8938e1b3d2c8e613f05884","title":"","text":"cc\nSo, I've been putting off commenting here to let these ideas sit, but let me leave a comment. I think I've reached a conclusion. TL;DR. I think we should mark these types as internal, but I think there are some better options for fixing this in the medium term, and this interaction should be taken into account as part of the \"MIR 2.0\" effort to rework places. Auto traits weren't really intended as a tool for probing layout, but rather semantic considerations. This is why traits like can be implemented by users. So I don't really think that auto traits give any sort of guarantee about their layout. Rather, this question is about is simply \"what are the constituent types exposed by a generator\", and this should correspond to the types that user code can directly access. The raw pointers here are not directly accessible. The values that are accessible are the \"live values\" that the user's code may later use -- and of course the code currently makes the constituent types be a superset of those, based on the AST structure. Of course, the real root cause of this error is a simplifying change to the definition of in MIR. It used to be that a Place had this grammar: but now we changed to just , which is why we are required to introduce the new temporary (and that holds the address of the ). As we've been talking about this change, I've been saying that we should be considering the older definition of as the one that is used by various analyses (and in particular by borrow check). This particular transformation of removing statics doesn't affect borrow check, but we failed to take into account the fact that the set of live variables can effect the definition of what is live in a generator. In particular, compiling for some expression requires a temporary unless corresponds to a place -- those places used to include statics like , but they no longer do. But I think that for analysis purposes, it should appear as if they do. We could fix this in two ways. We could write some code motion / duplication that takes temporaries like that are live across a yield and creates a fresh variable after the yield. The idea would be to make them never* live across a yield."}
{"_id":"doc-en-rust-5456e405bcedb3c9f9f92c31cc87d8cb9c61e409cc20a1b32e23a2c65c5da579","title":"","text":"We can do this because that operation is a compile-time constant, really, and thus the value doesn't need to be live across a yield. This might be worth doing as a size optimization regardless. Secondly, some of the proposals we've been kicking around for going further with simplifying include the idea of a distinct sort of temporaries that explicitly represent a \"partially constructed that hasn't been used by the user\". The idea was to allow borrowck (and other analyses) to trivially reconstruct the . We might want to add this interaction with auto-traits into the consideration for that design, and maybe it takes us some place (e.g., these special temporaries are not considered live for the purposes of auto traits). Having written out both of those options, though, I sort of lean towards the first, at least for this specific issue.\nI think these references and raw pointers created by MIR construction should be marked as . They are not visible at the language level. They can be viewed as just prefetching the address of a static, so the compiler could pick any type it likes for it (, , , some compiler internal type) so it must not affect auto trait inference. Drop flags are ignored for similar reasons. You cannot use an auto trait like this to detect them: So I think that should be reverted and the temporary static references should be marked as .\nNote: opened instituting this change and I r+'d it, since fixing the regression seems pretty important and time is of the essence; there is general consensus here on the thread; this is only restoring older behavior. In particular, there were some suggestions that this might be a lang team issue; I think there is some 'intersection' and I don't want the perception that I'm trying to shortcircuit discussion. That said, I also think this is primarily a compiler team matter, since it's a deviation from the old behavior, and further this deviation was caused by altering the MIR away from the \"natural, Rust-based\" definition and towards a lower-level definition."}
{"_id":"doc-en-rust-34cbfbfe58ba97fda33ff39e485cbb05e92d4db8f00e1440d3304a484c013e20","title":"","text":"A simple malformed macro makes the compiler crash. Code: Playpen error: Playpen:\nAnother case: Playpen:\nI had a crash in a bad macro which hits the same bug as Note that his/her error has the following which is a different stack trace: I'm on the latest beta; not nightly.\nI think you and I are getting a different panic from this bug. I've opened since the panic is in a different location in the code."}
{"_id":"doc-en-rust-4018551dac267ef28378021fb7bbc4c5e35bc18503b1e8ef23c1d818eb068b91","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\nlabel +F-dyn_star\n:laughing: the code thinks that this is a upcast, I think, rather than an unsize coercion. shouldn't be too hard to fix, but I may leave it for someone else. edit: nvm I'll just fix it."}
{"_id":"doc-en-rust-01d2a6e0236cf8f43cd09d26f30dba7a41be7bb417992c9cbd42d0737301118d","title":"","text":"I'm trying to build my crate on nightly, and I'm getting a compiler panic. I bisected several nightly builds to try and narrow down when the problem started. The last known good nightly was , and the first failing was The panic also occurs in . The crates causing the panic are available here:\ncc\ntriage: P-high, removing nomination label.\nMinimal repro:\nAs some info, I've narrowed down the offending commit to –– most likely the changes in ."}
{"_id":"doc-en-rust-07f455ab8d3245e09e11158804f664bc6b9f872353b4bf634000d5ee06f37e90","title":"","text":"I tried this code: When I run it under , I get this: Creating a reference from such pointer looks suspicious indeed. I could send a pull request that adds a condition there, but I want to ask first if this is being done because „we are , we can“, or if this is something that really should be fixed. : (but I've looked at the git sources and the thing is still there) <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI think it should only be UB to dereference the pointer you get from , so I'm not sure why Miri thinks there's UB happening. Just in case, prioritize\nBecause that pointer is being turned into a reference to feed to internally. And references are supposed to be always valid.\nLooks like fixed this for but missed it in .\nYes, seems this needs to use .\nI renamed the issue to reflect that the bug is actually in (which calls).\nCc\nAssuming you use the default flags for Miri, that change should not be required to make Miri pass, so I'd be surprised if doing the same change for would make any difference here. If it does, that seems like a bug in Miri that I should investigate.\nAh, but the in is indeed a problem (the PR was mostly about so I got side-tracked; the is what should not have any effect here). Miri ensures that references are at least dereferencable, so yeah that would explain the problem here. Good catch!\nYep, I apparently missed this somehow in . Fixing the indicated line to use should be enough to fix it; I'm preparing the patch currently. claim\nHm, Miri still complains, even after the fix landed... it seems Miri doesn't like being called with dangling pointers. I'll have to look into this.\nIIRC, when , I changed the type of the intrinsic to take a raw pointer rather than a reference, but miri wasn't touched, so that would make sense miri's still expecting a proper reference.\nPatch arrived really fast, we are assigning \"post-mortem\" a priority of as discussed as part of the and removing ."}
{"_id":"doc-en-rust-4797aadb00e43b1e79a06e5417dc4622eb7a7d0ca28b53c427560dfa7aa43aa4","title":"","text":"We need to add an epoch lint for It will lint , suggesting removal in root mods, and replacement with in non-root mods. This is blocked on the ability to elide extern crate in the first place.\nIt is also blocked on a feature to force linkage of a crate, see this comment and the discussion afterwards:\ncc\nI think the lint should be by default off in cases with , such as: This is because of the ergonomics problems with macros and the new macro import system, expressed here: It's bewildering for the migrating users if a lint tells them not to use the syntax, but then finding out that many of the macros out there have downright bad ergonomics with the import syntax. (For clarification: I think this is an undesirable state of affairs, and we should be linting against all , but if we do that, the ergonomics problem with the macro import should be fixed somehow.)\nI don't think we want at all, really. If we want to import macros, we should have another means of doing it. Otherwise we have an inconsistency. So yes, I think I agree with your last paragraph above all,\nI've discussed this a bit in the tracking issue for the macros import system:\nThanks, you expressed the exact concern I had in a concise way.\nAnother thing this needs to lint is unlisted crates that are included in that clash with existing modules. I'm not quite sure on what the story needs to be here cc\nDoes it? I've thought one of the things the path clarity RFC was about was to have separate namespaces for top level modules and extern crates.\nThe current plan has changed a bit so I'm not sure if that is still true. (If stuff does change it will probably be RFCd again, there's a bit of experimentation going on)\nSigh I hope we won't discuss all of this crap all over again... I don't enjoy that but it is not me who wants to change things.\nI've hidden your last comment, which I found hostile and unconstructive.\nIDK what has been hearing, but for me, this is the latest state of consensus on that issue, and it seems to have separate namespaces: is that the case? You seem unresponsive on IRC that's why I'm using github.\nThat's mostly the latest state of consensus, yeah. Some tweaks have been made iirc. Everything has been implemented."}
{"_id":"doc-en-rust-1508071aab5c3ca124f1c55a16ad46d3925f157d86a42f0fd907d4eebd01313a","title":"","text":"We need to find a way to implement Clone for where . In user code, \"cloning\" such a box manually is simple: will do it with a short roundtrip through which should be unproblematic. In the rust distribution, we can't impl Clone easily since the tools to do so are in libcollections but the Box type lives in liballoc.\nYou do not need vec for the implementation. Something like the following would work: Note that because can panic it is required to keep track of the partial result so the correct stuff is dropped.\nYes, that's nice that it can be carefully solved by essentially extracting the needed parts from what Vec does. But the Box code is otherwise so clean, it doesn't feel like the right way to do it.\nYou're welcome to suggest an alternative but I doubt it can be done in a manner that is both correct and significantly cleaner :)\nYour fundamental analysis is great: just isn't an exception safe representation while filling it with elements. It needs to keep track of the fill level, so a representation like Vec or BoxBuild is needed...\nClone is also wanted for , but that can be much simpler: There is no panic issue, and it can use a simple memcpy of the data."}
{"_id":"doc-en-rust-b2ea53401b10622d0a69a95ada7d3317373d7f24cc4204883daf669aad6f5a45","title":"","text":"Instead it should use the order that appear in the crate file. Even better, it should allow adding section headers (with a description) between them. Hypothetically: And get something like this: This would make both the source code and the documentation more accessible as the modules would be presented in a comprehensible order, with some description of each related group of modules. Edit: Rename issue to reflect that this isn't an either-or. Alphabetical order is useful, but so is programmer-specified order (to make the code accessible for newcomers) and Rustdoc should support both - see the thread below.\nShouldn't related modules be nested in submodules rather than logically ordered in the source? Finding things in long non-ordered lists is a real pain.\nYeah, I'm going to vote \"alphabetical\".\nHmmm. I pretty sure I put a comment here, and now its gone. Strange. Anyway. Here it goes again. Alphabetical order == random order. That's great when you know what you are looking for and just want to find it. When coming to a new non-trivial code base, being presented the content in random order is just about the worst possible way to access it. Nested modules allow us to group related modules together, and that's a good thing. If you have a long list of modules, certainly, group them. But this doesn't solve the problem. You now have a TOC where each level is randomized, which is still inaccessible. Searching for a function or module by name is an important use case, sure. But being able to access a new code base is as important, if not more so. Looking up a name in a short non-alphabetized list (at each level) isn't too hard, and one can always compensate for the lack of an alphabetical index by using ^F. Trying to understand a system presented in random order is next to impossible, and one can not compensate for the lack of a comprehensible order in a large system. If there was a way to specify the order of the entries in each level, which we agree should only contain \"a few\" entries, then the TOC would become accessible. If one could even add a bit of annotation for each level, so much the better."}
{"_id":"doc-en-rust-af5692b59224679d29ba1b59995be30bcfe074da711720163cc8dbe163762052","title":"","text":"The annotated TOC would serve as a very accessible way for a newcomer to understand the code base. And, this doesn't rule out also generating an alphabetically sorted reference index, beside the TOC. All good books do both - a TOC in reasonable order and an index for looking up data by name. We shouldn't have to choose, we should be able to get both. So, I misnamed the issue. It should be \"Rustdoc shouldn't list modules only alphabetically\".\nAgreed. Can someone rename the title?\nRename done.\nVisiting for triage. Minor, but still an issue.\nTriage, still listed alphabetically. Here's a sample source file: !"}
{"_id":"doc-en-rust-534e1717015c5d072ad75ef23b6fabc05af6acebd4a2d49c1e1aebceff0ad1be","title":"","text":"Rustc used to be able to replace with a constant when optimizing, not at the moment. It simply looks like a Layout method that is not inlinable. (This is a regression strictly speaking — stable & beta can do this optimization, but not nightly.) Code to reproduce:\nAre there any ways to write automated tests to check for \"regressions\" like this? Assertions against LLVM bitcode?\nYes can be used for this, e.g. Assuming this is run against the bitcode after optimization, that is.\ncc -- seems LLVM related\nNope. Just () that is not marked as inline.\ncc\nI didn't confirm that making Layout::repeat as inline fixes this, so please confirm that/add a test before closing."}
{"_id":"doc-en-rust-dac2d6bce56329614ea002f06291476af344a5be44fe25ead4d2826b6b8b7f0d","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 three printed TypeIds should be identical, as with the behavior in Rust <=1.70 Instead, this happened: switch between rust versions. I could not find reference in the that could explain such behavioral changes.\nif my bisection is correct, this surfaced in commit cc (makes sense?)\nI do not believe that is the correct PR to point at. Bisecting anything related to MIR opts can be tricky because you need to stabilize the MIR opt pipeline against changes like in that PR which don't actually implement any new behavior, they just change the meaning of MIR opt levels. Try bisecting with ? The above PR just changes the opt level 3 inliner behavior to be the default.\nReproduces since before with\nThis has to do with the fact that this impl: ... applies even when . Therefore in a polymorphic function like , we're eagerly inlining from that impl even though during monomorphization we'd prefer the built-in candidate instead. This seems problematic.\nWG-prioritization assigning priority (). label -I-prioritize +P-high"}
{"_id":"doc-en-rust-a80b97a4b1136e26628808d1be2a10e26d684af7165cc3301985491de63de5fb","title":"","text":"Passing rustc the flag and passing may produce different files (that is, outputs). This is true of rust-core (see below), though was not the case for a simpler (\"Hello, world!\") test file. Test script: Diff output indicates binary files differ. Tested with , rust-core on . rustc compiled from master on Arch Linux. If this is, in fact, expected behavior- sorry for the trouble, unexpected to me.\nCan you provide a diff between the outputs? This is likely a known issue, but I would like to be sure.\n.bc is a binary format, so just gives \"Binary files and differ\" as its output. On my machine, is 19K and is 62K. I'm not familiar enough with the format to extract much more data.\nI note the difference persists when the second line is (two separate flags), though both produce both artifacts.\nCan you pass and diff those outputs?\nWith emit flags as and respectively, there is no difference in and (according to diff.)\nIt seems that every bytecode is invalid only when a rlib is produced. It stopped working between rust-git-0.9.1301 and 1362 (shortly before 2014-02-23 15:37:05 -0800). Going back thorugh the log, I found I believe that creates deflated bytecode. Perhaps should be stored with extension or ."}
{"_id":"doc-en-rust-c3d71db05f58ca4f54afce7b9ce574cc4d204442ef32ef20532c10eb344eb89a","title":"","text":"The and traits contain convenience methods and wrapping and . This issue tracks addition of similar methods to trait's and . This is implemented in .\nif this is a tracking issue, maybe it should have the label\nWe should eventually add similar methods to .\nI know nothing about developing on Windows so I can't do it myself but I guess a PR would be accepted. Can we stabilize this? Is there anything that still needs to be done?\nSeems reasonable to me! 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] [ ] 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.\nWhat's the next step? Should I make a PR to stabilize? Sorry but I don't fully understand how things work yet.\nindeed that should be all that's necessary! If you'd like to make the PR you're also more than welcome to do so!"}
{"_id":"doc-en-rust-d276d3e93a75aa1475bbb78a0eb01d825c6f04cfab539bfd15c93b5d66e7797e","title":"","text":"Having written Python for several hours, I made this mistake and couldn't realize what was wrong for a while. No response claim <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI'm not sure whether it's worth to fix this right now. will significantly change this code, basically requiring a rewrite of this diagnostic.\nAgreed, it's reasonable to wait for type ascription removal. Thanks for the info!\nNow we should fix this error message: is not OK, we'd better suggest to use . I think you need to add proper logic for this part of code:"}
{"_id":"doc-en-rust-af3d2230aad15cc68acee8c540d3300b7de8b977332bd80ef9fd1fa98b3c3c7c","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: named field access on non-ADT', 'error: internal compiler error: named field access on non-ADT' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: 22 | let buf: &mut [*const dyn Foo] = &mut [&u8, &u8.0, &u32, &u32.0]; [livesymbolsandignoredderivedtraits] finding live symbols in crate [checkmod_deathness] checking deathness of variables in top-level module [analysis] running analysis passes on this crate --\nmmh this bisects to cc"}
{"_id":"doc-en-rust-ab69f4d9969aee6a4577d1e4d9383d91bf2070a52f47a9eb39364871b72451f4","title":"","text":"with rustc 1.0.0-nightly ( 2015-03-01) (built 2015-03-01)\nThis is still an issue\nStill an issue in 1.0.0.\nThis is still an issue in 1.3.0-nightly: $ rustc error: internal compiler error: unexpected panic thread 'rustc' panicked at 'assertion failed: <= ()', stack backtrace: 1: 0x7fd6c19bd5ee - sys::backtrace::write::h04a6ced565b26815Lqs 2: 0x7fd6c19c5214 - panicking::onpanic::h521f84b604e22dfel8w 3: 0x7fd6c198804e - rt::unwind::beginunwindinner::hd3dee614a0e1c16cZNw 4: 0x7fd6c1988d7c - rt::unwind::beginunwindfmt::ha4ce6704c81423045Mw 5: 0x7fd6c19c4dd6 - rustbeginunwind 6: 0x7fd6c1a15bb4 - panicking::panicfmt::he89ea3094b3178e919B 7: 0x7fd6c1a0f9dd - panicking::panic::h9e565ee21070221by8B 8: 0x7fd6c11f8271 - astconv::finishresolvingdeftoty::h03670159ac2fefe7aTv 9: 0x7fd6c11b6340 - astconv::asttytoty::hb2c49d2cf31c029bYUv 10: 0x7fd6c1189eed - check::closure::checkexprclosure::hbce85e7beaf0ebd52zl 11: 0x7fd6c11d360b - check::checkexprwithunifier::h16314096699859592584 12: 0x7fd6c11f998b - check::checkdeclinitializer::h491ede37e45bce9e84r 13:"}
{"_id":"doc-en-rust-26d157b01817fdc3c6ed7f33b48729b2f8339d2d051e3d782f305e86275e59b8","title":"","text":"0x7fd6c11f9a4d - check::checkdecllocal::h1c782249285c9ae3m6r 14: 0x7fd6c11f9c79 - check::checkstmt::h48bf6ea3f412b86bf8r 15: 0x7fd6c11a91b3 - check::checkblockwithexpected::h072b2c4702c43b1cjcs 16: 0x7fd6c118bef4 - check::checkfn::h8218f9adb3734183iQn 17: 0x7fd6c11a35ca - check::checkbarefn::h3c567a2d1339f838RFn 18: 0x7fd6c11a1523 - check::checkitembody::h8e17e6521c30131ay6n 19: 0x7fd6c11a31e4 - check::checkitemtypes::h62e908b1d9f74b39oDn 20: 0x7fd6c12609b8 - checkcrate::h594ee0148d251222uZC 21: 0x7fd6c1f1dc69 - driver::phase3runanalysispasses::closure."}
{"_id":"doc-en-rust-e7a4475092a1d6a3401a9b9913b26dc20e4b595be6ef82e7d7912d79bb13338e","title":"","text":"22: 0x7fd6c1f1c633 - middle::ty::ctxt<'tcx::createandenter::h349256048753845929 23: 0x7fd6c1f17a17 - driver::phase3runanalysispasses::h15521018079403107052 24: 0x7fd6c1efa266 - driver::compileinput::hbf698b02349f7ce3Tba 25: 0x7fd6c1fd3ed3 - runcompiler::hd724b5fef3441688y7b 26: 0x7fd6c1fd18ae - boxed::F.FnBox<A::callbox::h6609070342514802751 27: 0x7fd6c1fd10f9 - rt::unwind::try::tryfn::h10774555836369096370 28: 0x7fd6c1a3ed48 - rusttryinner 29: 0x7fd6c1a3ed35 - rusttry 30: 0x7fd6c19b08a7 - rt::unwind::try::innertry::hb0d7a3eb324339ceSJw 31: 0x7fd6c1fd130b - boxed::F.FnBox<A::callbox::h18179817771297192954 32: 0x7fd6c19c3e71 - sys::thread::Thread::new::threadstart::hf8c7448e27294ed0PTv 33: 0x7fd6bb60f353 - startthread 34: 0x7fd6c161ebfc - _clone 35: 0x0 - <unknown\n$ rustc --version rustc 1.3.0-nightly ( 2015-06-30)\nThis problem has gone away for me now. It may have been from mixing versions? It may have gone away after a .\nIt is still an issue on nightly according to the playpen:\nYou're right. I must have been in the wrong project.\nI just ran into the same assertion (with both stable 1.1 and nightly 1.3), but with different code."}
{"_id":"doc-en-rust-09c4a7631dae8161f05ed8e197f5dcee2804128b1f7143cbb7677ff4932eb2b9","title":"","text":"Would it help if I try to create another minimal working example and post it here or a new bug report? This is my backtrace: didn't help.\nOkay here it is: Unfortunately it has something to do with glium, so I guess this doesn't help much :/\nMay be related, not sure: (rustc 1.2.0 ( 2015-08-03))\nminimized:"}
{"_id":"doc-en-rust-dd66f626e30f9a422ef543deab970d3dbd7b6175d2cb3eb638f16edd4a301a95","title":"","text":"No response No response No response\nI thought the intent with was to use it in a passthrough style, so you can insert it into existing expressions ie. becomes . In which case, maybe the lint should be for not using the value resulting from evaluating .\nNot sure about the majority of users but for me is a convenience over . I use it without using the return value almost all of the time.\nProbably a common thing to do, sure, but if we're talking about adding a lint, why not nudge the user in the direction of the intended and documented usage? You could at least do both: \"insert into an existing expression or pass it a borrow\" etc.\nThe fix in will only report a hint when there is already a happened. For example this code: before this fix the error is: with the fix, since there is already a error, the lint will try to find out the original macro, and suggest a borrow: The suggestion is not 100% right, since if we change it to , we need one more extra fix now(the return type is not expecting a reference), but there is a different issue, at least we have already moved one step on. If the original code is: Then suggest a borrow is a great and correct hint.\nSimilar in the scenario of function argument: original error is: new errors from the fix:\nWould not also be a good hint? The suggestion wouldn't compile anyway right? Because would need to change to take ? Without involved, the compiler does indeed suggest that: Once that's addressed (whichever way it's done), once again becomes transparent, and eg. or works. does not, however, and I see why a \"consider borrowing\" hint would be good there. However, if you make the change first and leave as-is, the resulting error does not include the suggestion to change , which is unhelpful. (I agree that the message is even less helpful though, I'm not disputing that.)\nYes, it's a good hint, but from the implementation view of a hint, it's much harder to analyze the following code from the error point and then construct a new expression. Even it seems an easy thing for humans. You are right, the suggestion is not 100% right, we may need an extra follow-up fix after applying the hint, which is also a common thing in rustc diagnostics."}
{"_id":"doc-en-rust-a6f3ca09c638c7e9ada8bc090b658d6bab916c9ab98428da1fedbf3e627518ef","title":"","text":", and a few others have summaries as given in the source code, but , and a few others somehow don't. This is perplexing when we recall the method impls are generated by macros\ncc I'll try to take a look in the next days."}
{"_id":"doc-en-rust-d8977df5e10b75cc49fbb47eb9f2a769467cee6682dc525ce06703efc8a957e5","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 suggest -ing the out-of-scope trait, similar to E0599: <!-- If the problem is not self-explanatory, please provide a rationale for the change. --Someone tried to do dynamic dispatch between two underlying used a boxed trait object (with the type spelled , so wasn't in scope) and call the method on the boxed reader, and it was unclear from the error why the method wasn't accessible: <!-- 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. --This is reproducible on nightly (rustc 1.67.0-nightly ( 2022-12-01)).\nNote: A sign there may be a problem worth fixing here is the code I wrote is a near copypaste of a top stack overflow answer for a :)\nSo, after some investigating, this appears to be a regression of , which essentially the same suggestion I proposed here: adding a for the trait object's trait. When generating the error when the lookup fails, the trait is initially included in the list of candidates, but it's filtered out by this (because the callee is the trait method, and so the parent of the callee is the trait, which is the candidate): This was introduced in by which also removed the corresponding suggestion from the test's expected output. It's not immediately clear to me from the PR () why this change was necessary. If the call is removed, the only UI test that fails is the one. Reverting that change would fix this issue, but I'm not sure if there are other cases I'm missing."}
{"_id":"doc-en-rust-5f960f59572946d373b6c33323ee34953a0738c81a0bfbea0a933aa8d60f79bf","title":"","text":"(cc with whom I was discussing this on Mastodon)\nHaven't look at this yet, maybe I misinterpreted what was achieving, and that commit just needs a revert -- can't recall why I did that.\nYeah, lol, I totally overlooked that the would be load-bearing due to the way we treat trait methods on as inherent. I'll revert , modify the test, etc."}
{"_id":"doc-en-rust-bf02cff849637e34b780957988347f5e3bb12fc557fa33d07b85804f11218daa","title":"","text":"(Edit: Actually, being an inherent fn doesn't matter. It happens with top-level fns too.) This prints the diagnostic: The suggestion in the last line is not valid syntax (). It also emits malformed syntax if the first parameter is a or parameter. The diagnostic becomes well-formed if any of the following is done: The first parameter is changed to instead ofThe fn is not an async fn. In either case, the diagnostic correctly says: Happens on both nightly: ... and stable:\nThis should hopefully be a fairly straightforward patch to the diagnostics code that generates the suggestion."}
{"_id":"doc-en-rust-75effd16b0a447141390847a66f06387ebe0f56068dc3dab9b391f7497509e5a","title":"","text":"When confusing a Fn-like struct with a regular struct in an pattern, the output leaves a lot to be desired: <details<summary<a href=\"\"Current output</a</summary</detailsWe should probably collect all these errors into a single diagnostic error: Even better if there was only one diagnostic."}
{"_id":"doc-en-rust-b0f76e335d3badee54ff91c284523808a5f4e33eb6bbb1afdb963f102490878c","title":"","text":"On linux, , then run: This changes the permissions of to . Is this expected? masks away everything other than the lower 3 triads when it calls out to this code: Then sends these mode bits into into chmod which considers four triads, not three. Possibly useful references: and Should we change Metadata.permissions to preserve that triad, maybe by masking with instead of ?\nI guess the solution depends on whether Unix's std::fs::Permissions is supposed to care about 9 bits or 12 (this is not an implementation detail since it's exposed to the programmer via of PermissionsExt). any thoughts on this?\nIt seems to me like we should extend the mask to the full 12 bits.\nSeems reasonable to me to avoid masking where it makes sense!"}
{"_id":"doc-en-rust-7ada8d6f69606f3b233f58af8491570449e4c55a0546ecf90df357a91b9c5b9b","title":"","text":"Since InstCombine can now introduce where there was none before, without checking that the value is in fact not used afterwards. This may cause a value to be marked as uninitialized by the dataflow, but still be used in that uninitialized state. If InstCombine ran before the generator transform this would be acutely unsound and could probably be exploited directly, but other than that transform I don't think we rely on this property yet. This impacts , which does run after InstCombine and relies on the dataflow. I've observed this on , where it produces this diff: The second use of occurs despite the first move deinitializing the local. cc\nMaybe we should stop making instcombine convert to ? This could be done in the pre-codegen cleanups, but for MIR it is wrong to use or on such values in general. Alternatively instcombine needs to start using dataflow to only insert moves when the site is the last use of the local."}
{"_id":"doc-en-rust-a74a6a28ad143b441ce913e52da3ba850af414bfd2da9ec9dc1b3011f049a693","title":"","text":"Right now on our bots we're basically in a state where if valgrind rpass tests are compiled dynamically they will all fail, but when compiled statically they will pass. I'm not really sure what's going on unfortunately, but this is either a bug in valgrind or a bug with us, and we should know precisely what it is to ensure something more sinister isn't lurking. Some links: - first pass at linking tests statically, fixed - another pass at linking all tests statically\nAll the failures seem to be within platform’s dynamic loader. Here’s a few things to try: updating kernel+glibc to the most recent versions (4.4-ish and 2.23-ish, respectively) help? downgrading kernel+glibc to some older version help? non-linux/non-glibc work correctly?\nAny news/changes on this one ?"}
{"_id":"doc-en-rust-4ec7e73a404ac76d69c671c6f06db99d936ae8f0078fcfaac8411a19baadc5dd","title":"","text":"Update test file to use + annotations instead of (see https://rust-) The files need to update are: - <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nis the correct file name , not ? And what about this comment?\nIs the problem fixed ? If not, I would like to work on it !\nWIP PR has been closed due to inactivity so you can work on this.\nI would like to be assigned to this issue. Am I supposed to do a new pull request ?\nclaim Go ahead!\nError: Parsing assign command in failed: claim Please let know if you're having trouble with this bot.\nclaim\nError: Parsing assign command in failed: claim Please let know if you're having trouble with this bot.\nHmm, it's odd, anyway, you can assign the issue to yourself by comment Ah, I mistaken the command, the collect one is , sorry.\nclaim\nIf I understood well the problem: I must replace all the by just , even if comment exist ? Because the output changes, I should modify the .stderr version I must change with in , and as should raise an error we add why add in the version ?"}
{"_id":"doc-en-rust-84511733c8e9f4c03f15d339c19a679cd1f2c15f77826146a82337436a64d419","title":"","text":"See I propose to change the license of Non trivial contributors: OK OK Contributors appearing in git blame that are trivial: OK 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 () Cheers\nI agree to relicense any previous contributions to according to the term of the Computer Language Benchmarks Game license ()"}
{"_id":"doc-en-rust-ded8174e54900f87470131eb9a7413cb6ed146d7d7347f97b8465da4913ff300","title":"","text":"cargo is relying on the to find rustc, but if one runs cargo with , cargo will error out with the unhelpful: cargo should detect this and return a proper error message for this. A proper workaround for this is to make sure that has an absolute path to the binaries set, as in: It needs to be absolute because cargo does a chdir to the build directory, which would break a relative path.\nWe have a function, that cargo can use to determine the path to itself, then use to launch the corresponding rustc."}
{"_id":"doc-en-rust-9b23404c624087e4b6f505e241c33a30618643f870354e7d6c1e0c1a714a2788","title":"","text":"Instead of just saying the key can't be verified, explain why.\nYeah, it should also not fail! Missing gpg is a warning condition, not an error condition."}
{"_id":"doc-en-rust-eb2fa8dbea601a2fa522688f15f1908b4b5e59fb8f718b9f99afe618053aa195","title":"","text":"Note: the below reduction originally came from a + in the wild. I haven't found a way to demonstrate this outside of the \"float inference vars + method\" combo, but: works on stable () and beta (), and errors on nightly with: Even though it doesn't show the source for candidate , I'm almost certain it's this: from (cc On the original PR I left comments like , trying to rectify the issues with the original approach, but they didn't go anywhere and the version that one in the end is the (arguably) more fragile original one, that uses blanket s and works around their unwanted interactions. It's possible in this case all it takes is checking for \"float inference vars\" and making sure they can never be considered to implement , but I'm worried there might be other edge cases lurking in the shadows. Also, did both of those PRs skip crater? I feel like this shouldn't be that hard to hit in the wild.\nWG-prioritization assigning priority (). label -I-prioritize +P-high"}
{"_id":"doc-en-rust-28b5bdb0153ac64fbe575fdb9da5ff53f590d23a356ab8894e8a47c073c0569c","title":"","text":"The \"Install MSYS2\" step of failed, but the build kept going and failed later with obscure errors. We should fix this so that if msys2 installation fails the build fails immediately!"}
{"_id":"doc-en-rust-b644a10cf9202b1eeecaecfde65d48af02e173d50f2532cc116c6dbd5936ff5f","title":"","text":"crashes on nightly () and also on stable () with \"nightly\" features turned on via . It does not trigger on stable without flag. Here is the output I'm getting: I created a small repro case + here: (it only happens when there is a certain combination of procedural macros, so I cannot make it a single file).\nThe source code is: with crate being a procedural macro crate with:\nCouple of things that are important here: only happens with two procedural macros. macro has to do that . attribute has to be , does not reproduce with anything else.\nJust a heads-up: AFAIK if a bug only occurs on stable with (I understand that it is not the case here), then it should probably be disregarded, because isn't supposed to be used when not bootstrapping the compiler.\nThe bug itself reminds me of\nit happens on nightly as well. That detail was included to give context that evidently the ICE has been present for longer than 12 weeks, I believe.\nWith the following patch in the linked repo, the output is not ideal, but preferable to the ICE: I'll take a look to see if we can somehow keep the span for the entire attr doc, or at worst pointing at the correct macro.\nChanging the patch to be gives us which makes more sense but is missing a primary span. Edit: I see no way to recover the original span after its has been modified. I guess we already rely on proc macro writers to be nice when it comes to spans, so this is acceptable as well."}
{"_id":"doc-en-rust-7c709c2f5ae2ada94580a48e8d8ea5a7ce339728a9d7168b9b77fe08cb0eac1d","title":"","text":"Repro: As of current nightly: This is the unreachable line: The same crash reproduces back to 1.47.0. Older stable compilers do not crash:\nBisect: searched nightlies: from nightly-2020-07-10 to nightly-2020-08-27 regressed nightly: nightly-2020-07-22 searched commits: from to regressed commit: () Mentioning because appears the most relevant.\nAssigning ."}
{"_id":"doc-en-rust-9da6e95c335f48d6b06b8a6cd003c89c70bc53bedd6bf2c5c7ac9bd6bf6d5f89","title":"","text":"I tried this code: I expected to catch lint and suppress it, as it should. Instead, compiler issues a diagnostic both about unused value and unfulfilled lint expectation: It does work as expected though if is applied to function. I used the latest stable (Rust 1.81), but it is reproducible both on latest beta (2024-09-04 ) and latest nightly (2024-09-05 ). labels: +F-lintreasons, +A-diagnostics <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nThis issue is not limited to just . Others attrs like or don't work either. For instance, the following variant of the reproducer with replaced with emits the warning even though it shouldn't: Playground: This broken behaviour goes as far back as at least 2021 (couldn't build and test earlier rustc) We emit the lint on the HIR node corresponding to . However, the or levels, which are supposed to override the default level of the lint, are associated with or bound to the node underlying the as shown in the figure below: The end result is that the lint's level is never knocked down to or since when searching for levels we start from the node on which the lint is triggered and go up the chain of parents. So in this case we look for the level on and then on the and so on. We never look for it on the where the levels actually exist. As it happens in the lowered HIR does have the / attrs for both the node and its child node. However when adding the levels in the we do not add anything for the node as shown here (note the comment): If were to add the level for as well the issue will go away. However, if we do that we will still have one problem in the case of which is that we will end up with two expectations and the one on the will not be fullfilled and hence we will still see a warning about unfulfilled expectation. To prevent that I think we should take the following approach: when an attr like or etc."}
{"_id":"doc-en-rust-79ae52ec28826e7fd5d0571036ba651615fc4170373c979f134af2d5a515bd5f","title":"","text":"are present for more than one HIR node in the and if one node is the (direct or indirect) parent of the other node, then add the level only_ for parent node. This will take care of any lints on the child (since we always walk up the HIR hierachy as mentioned earlier) as well as the parent and it will not cause any warnings about missed expectations. I am new to this area so if someone can review this idea or suggest alternatives that will be great. since you seemed to have worked in this area recently, can you please weigh in?\nYour investigation is accurate, and the fix is simple: visit the statement node when building lint levels. Do you mind making such a pr ? I don't think we need any special adjustment for cases, duplicated attributes are already taken into account, but a test won't hurt.\nThanks . Yes, I'll put together a PR. My only concern is if all we do is add the level at , although it will work perfectly for , etc., in the case of we will end up with an unfulfilled expectation on the node which will appear to the user as a warning. But anyway let me have a go and see what happens.\nOpened draft PR that adds the lint on . It does suffer from the extra warning problem."}
{"_id":"doc-en-rust-0433e96f1fea1692a6dbda2b304cc4ffe74d1cf8031552073123b81e4ce976c8","title":"","text":"Tracking issue for rust-lang/rfcs.\nIs anyone working on implementation already? If not I can take a crack at it.\nI'll probably do it.\nHuh oh, we have an issue already: do we mean to include potentially minus-prefixed literals? If yes, we have a problem because 1. it means we have to return an Expr instead of a Lit, which means I'm not sure one will be able to use the bound fragment in a non-expr context (for example in a static array type?) and 2. it's no longer always a single-TT, so the benefits in terms of future-proofing are a bit less good. If we don't... well, we loose expressivity. I have no idea what is more intuitive though... Would you, as a Rust user, expect to parse ? I certainly can think of use cases for this...\ngood point. I think I would have expected it, I also agree with the complications.\nCan't we upgrade Lit to support negative literals?\nI'd expect \"literal\" (or a future integer-literal specifier) to include (negative 5), but not (the negation of positive 5). Perhaps that expectation doesn't match reality, though. For instance, based on parsing rules for non-literals, I'd expect to act like . So, if handling both and as literals makes this easier, that works. But \"literal\" definitely needs to include negative numbers, or we'd have a weird user trap to explain.\nI'd expect \"literal\" (or a future integer-literal specifier) to include -5 (negative 5), but not - 5 (the negation of positive 5). Unary operators, including minus, are processed purely by the parser at the moment, no lexer involved. So their treatment is whitespace agnostic. (I personally think this is a good thing.)\nI agree with is not syntactically different from and has no reason to be. But I also agree with the fact that the user will probably expect negative numbers to work as literals (even it – syntactically – they're not).\nis also supported in literal patterns while arbitrary expressions are not. It'd be reasonable to support it in fragments as well.\nAnother thing that won't match is a macro call, like , or any of the other macros that I think of as expanding to a literal (, ...)."}
{"_id":"doc-en-rust-9d182356753c860866613db5fde7e24272669928c2adea54b67398cbbb488354","title":"","text":"I dunno, maybe this is not such a good idea after all. Re-reading the RFC in a more skeptical light, I felt like the \"Motivation\" section could use some more concrete use cases. Maybe this is just failure of imagination on my part, though! I think the likelihood of this feature attracting people who really want constant expressions should be acknowledged as a drawback, too.\nThat's fine IMO. Personally I'd like it to match only explicit literals in code to distinguish, for example, between literal and identifier and produce different code for them. Right now this is not possible because all of , , are too broad and conflict with each other.\nHi All, I have implemented this feature in my fork of Rust over 1.25.0, under this branch: Following a quick review by a rustc mentor I may have the free time to provide a full pull request for this.\nBTW label has the tooltip \"implemented in nightly and unstable\" but I did not see it there, i.e. commits & pull requests referencing this. Did I miss it?\nThe implementation that I worked on was merged, yay!\nIs there anything stopping an FCP for this?\nIt's currently merged in unstable; do you mean an FCP to declare it stable?\nYes, an FCP to stabilise. Should have clarified.\nCurrently, it is not possible to pass a literal from a macro to another macro. . I think this is a bug.\nInteresting! That is a bug. I opened to track it.\nAgreed, this should be allowed just like passing any other node types.\nIs there anything else preventing this from being stabilized? The issue above has been fixed.\nThis has baked for some time now and I believe it should be ready for stabilization. So let's start the review. merge The feature gate test is here: Unstable book: Tests defined here:\nTeam member has proposed to merge this. The next step is review by the rest of the tagged teams: [x] [x] [x] [x] [x] [ ] [x] [x] [x] [ ] No concerns currently listed. Once a majority of reviewers approve (and none object), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up!"}
{"_id":"doc-en-rust-ba319ab491e9a33d298d8cade668ea28bf8dd31af2044c7a4651474f66faed76","title":"","text":"See for info about what commands tagged team members can give me.\nReading through the tests, I see that is a literal. While that makes sense to me, I remember hearing that it wasn't, but was instead a negation operator and a literal. Am I misremembering?\ncc on\nI agree that it makes sense. I would say that even if is interpreted as negation + a literal, I would probably still want the macro matcher to accept since that behavior seems more intuitive. In other words, I would see being more as an implementation detail than what a literal is in the mental model.\nI think that the nuance with causes a bit of a problem, because I don't think it should be treated as a literal, but I also don't think that the current implementation of would allow detecting it either. You could naïvely allow but that would allow which is clearly wrong.\nthere are tests currently implemented that verify that is detected as a literal.\nI worded that wrong; I meant that only having a matcher and not being able to distinguish strings and numbers means that you can't easily make not a literal.\nfor procedural macros the input as lexed by the compiler is (two tokens) but procedural macros can create tokens that are negatives (like ). In that sense matching for makes sense to me.\nAre literals generated by the compiler counted as true literals? A quick example would be something like: This fails to match, as the expansion, I guess, happens after the selection. I just naively assumed that would have worked.\nis not a literal generated by the compiler, it is an identifier followed by an exclamation mark followed by a set of parentheses containing some tokens. See for example: If you were to use it in expression position, it would be interpreted as an invocation of which expands to a string literal. In this case and in your macro though, it is never in a syntactic position where it would be treated as an expression.\nI can understand semantically why it doesn't make sense, I just thought it would have, but that being said, I already changed it to , so there's no issue. It just made more sense to me as a literal, because according to the compiler, it could generate a literal from it. I guess it was more a question than an actual issue.\nThis is true, but there's more to it!"}
{"_id":"doc-en-rust-721bfecc35df475bca4ea1dad1c9601a73cf036bdeb04b87c9488b5714dd1929","title":"","text":"A few built-in macros can expand their arguments eagerly through ~m a g i c~, so they accept and likes even if they expect string literals: Fortunately (or not), this currently cannot be done in user-defined macros.\nI actually just realised that I can't change it to , as it's used in . So, I've just had to manually unroll the macro. ! It doesn't look pretty. :( Ninja edit: I just tested what actually happens if you try to pass in a non-literal with . It rejects it the exact same way. Does the already make use of this feature? If not, the seems to propagate the required token. Oh, unless the compiler steps in... That's actually probably the case... I've reverted it back to the type.\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.\nSince you implemented this, would you be willing to write up the stabilization PR?\nsure\nThis appears to be missing from the Rust reference"}
{"_id":"doc-en-rust-fb6c2b7293948418dacd066e2443df69f06462bb9ddabc0ee4f62acdb26dc3b5","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 --\nclaim\nlabel +S-bug-has-mcve\nI'm having trouble understanding this ICE. Could someone point me in the right direction? Thanks for your help!\nrelease-assignment I'm finding this quite hard. For anyone else: I suspect is responsible."}
{"_id":"doc-en-rust-7a9cb418013612ad269cf96d0ff42f69f582d0034017b7851537538c0622479b","title":"","text":"The fix for CVE-2022- (, ) appears to have introduced a regression that can cause file system corruption on some UNIX systems. The new code will attempt to use in any case where it does not know what type of file a directory entry represents. Some systems do not provide that information along with the entry names returned while reading a directory, and even on systems which provide a type hint, that hint may be . In cases where we do not know the type of the entry, the code tries first to unlink it as if it were something other than a directory: The code assumes that on a directory will fail with , or on Linux with the non-standard , but this is not always the case. POSIX does suggests as a failure in some, but not all cases: (See in The Open Group Base Specifications Issue 7, 2018 edition) Implementations are not required to prohibit on directories, and indeed UFS file systems on present day illumos and presumably at least some Solaris systems allow of a directory if the user has sufficient privileges. Other platforms may as well. Unfortunately unlinking a directory on UFS causes a sort of file system corruption that requires an unmount and a trip through to correct. Any code that uses on UFS has since started causing that kind of corruption, which took a bit of work to track down. I think the fix is probably relatively simple, and has the benefit of not touching the code path where we believe we know what sort of entry we are removing: In short, we should try to first, rather than first, as that always fails in a safe way that we can detect. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\ncc (as you're the one how wrote the new code)\nThanks for the ping claim\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-critical\nWas this issue reported upstream? Filesystems corrupting themselves seem like a poor failure mode in any case, and in some ways is a violation of the sandboxing that the kernel ought to provide for the user-space applications."}
{"_id":"doc-en-rust-f0e325a6b176de3d959bafcb9afe520ea0d1ea6abadc0d684369f6565a732df1","title":"","text":"It was reported upstream, and we're working on a fix -- but that fix will obviously only be in new versions of the operating system. To expand further on the corruption: the file system becomes inconsistent and requires repair, and the damage such as it is can only be caused by privileged users; i.e., by root or a user with root equivalent privileges. I am not yet aware of a way that it would cause actual data loss, just an interruption to service, but anything is possible. Allowing the linking and unlinking of directories is a regrettable, but seemingly intentional feature we are saddled with through our UNIX heritage. I'm working to disable and eventually remove the feature in the OS -- although we strongly value backwards compatibility, in this case I can't really see a legitimate use case or find a consumer that would be broken by doing so, but we won't know for sure until we try. While this specific case is unfortunate, and we can and will work on our end to try to mitigate the impact, the fact remains that POSIX explicitly documents and allows for implementations where on a directory does not return . For the code to be completely correct on all POSIX systems, it cannot make that assumption. In addition, working around the issue in new versions of the OS doesn't fix existing deployments out there already. Enterprise customers are often reluctant to promptly update their operating system, even though they may update software built and deployed on it -- software that may be written in Rust. I myself hit this issue by upgrading only the Rust compiler to a new stable version, and trying to build and use Rust-based software we have to build UFS ramdisks on illumos. We aim to fix the OS for the future, but the critical regression in Rust needs to be fixed as well for the present. We appreciate everybody who has looked at this so far -- please let me know how I can help expedite the process!\nThanks again for the report. The linked PR should fix the issue. Apparently only and guarantee that trying to a directory fails. , and allow it, at least in theory. After looking around a bit I found that it is even explicitly documented for and . So it is not a bug but a feature there... After changing that in you might want to adapt the man page as well."}
{"_id":"doc-en-rust-f0009f736f4eba53cfa2eb49a9f4f625dac08d77b4a17edb0042b59731d87724","title":"","text":"We can try to avoid this case by default, as is switching to try unknown as a directory first, but you should note that this is still going to be racy. If there's an unprivileged adversary like the CVE supposes, then they can try to race changes between \"try (and fail) as a directory\" to \"unlink as a file\", to make it unlink a directory after all and induce corruption. IOW, it sounds like it's not safe for a privileged process to unlink paths at all if they may be changed by lesser privileges .\nIt should not really cause corruption according to the , just orphaned directories: Of course this can lead to resource exhaustion since the disk space and the inodes cannot be reclaimed until the next .\nAnd that user is only root or otherwise root-like? i.e. it's not just talking about regular access privileges?\nFor Illumos the process must have root privileges or needs to be in the process privilege set (). Solaris has at some point abolished this privilege and apparently does not allow unlinking directories anymore ()."}
{"_id":"doc-en-rust-7eb3c566a4cc705575f4c2ee3217e12bb55b9548ee9b0475cdedd41fa840b6a5","title":"","text":"There is a panic safety issue in : after a call panics, the impl of calls again, which means the buffer contents are potentially written twice. This may cause an application to overwrite parts of a file that it did not mean to overwrite (in a DB engine written in Rust, this could cause unrecoverable data corruption!). Demonstration: The expected output of the demo program is , the actual output is: More generally, we need a story for panic safety in Rust. My takeaway from the related discussions (e.g. , , the trait) was that only code and impls should have to worry about panic safety. The demo app contains none of these, so I'd consider this a bug in . (otherwise all implementations would need to provide the strong exception safety guarantee?) Solution: could use temporarily mark the buffer as empty during the calls; so that the impl doesn't do anything after a panic. However, this doesn't help if the panic occurs during a call...\nNote that Rust is normally referring to \"memory safety\" when talking about safety, so the issue here isn't in conflict with the related discussions. It's definitely a bug in , but I want to point out how specific it is here: the only reason you have odd behaviour is because you have a implementation that will panic after successfully writing the data it is given. I'm all for making more robust, but it's not just \"if the call panics\", it's \"if the call panics after successfully writing data\". Panicking before a successful write (or if the write fails), would not have the same issue.\nIf your impl is panicking in the middle of a write, it seems to me like you're in data corruption land with or without a second write. This is not quite the case - and thread locals expand that surface area. What's specifically the expected behavior here? Is the implementation specifically the thing that needs tweaking, or should the totally poison itself? For reference, Java's class has no special handling for exceptions thrown from the inner : , so adjusting alone seems like a reasonable route to take.\nWithout the , a panic in the middle of a write (without ) only corrupts the part of the file that the application meant to overwrite. In a DB engine context, that means the resulting corruption can be repaired when the transaction is rolled back."}
{"_id":"doc-en-rust-6614dcbedfbb2f754c1340f1bd29d576b23573a905cee9a4431a1c2203f10d3e","title":"","text":"But with , a panic after some data was written might corrupt parts of the file that are not saved in the rollback journal, so recovery not possible. I think we need some guideline like: If a method call panics, it's a bug to call any additional methods on the same object. Thus, the bug is in . may need something similar to a poison-flag so that the impl can detect whether a previous call panicked, but it doesn't need to protect against it's own methods being called after a panic (that would be considered a bug in the caller). The Java has the same problem, but the expectation in the Java world is different: it's trivially possible to catch an exception and continue using the potentially-invalid state; so in Java's case I would argue that all implementations should provide the strong exception safety guarantee to avoid this kind of issue. Essentially, the Rust world needs to decide between a Java/C++-style \"strong exception safety guarantee\" (=failing method call should not have any side effects) or a new \"no-use-after-panic guarantee\" (=after a failing method call, no additional method calls should occur). Some types (like BufWriter) can be compatible with at most one of the guarantees -- strong exception safety requires that a panicking call has no side effects; no-use-after-panic requires that a panicking call has the side effect of suppressing the buffer flush in the impl. The trait seems to be roughly equivalent to basic exception safety. Types that do not implement instead live in the world. Generic types implementing need to be careful not to call any functions on the type parameter from within the implementation if a previous call panicked (unless they use a bound).\ntriage: P-medium is fixing the data corruption in"}
{"_id":"doc-en-rust-118433c31bc29716faff9a460042fc6c662b57f7865f844f06298dd3fb733f90","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. --It should name the traits are attempted to be coerced, maybe tell me why that's not allowed (yet), etc. Right now it just highlights the entire line. The original example I had that made me run into this issue had an even longer expression there (multiple chained iterator methods) which just got all highlighted as one big block saying \"somewhere here trait coercion is used and it's not allowed\". Note that I understand why it's not allowed, I was just disappointed by the error message. I already talked to about this, and they also thought this output may be problematic. Even though the feature may be unstable, it's quite easy to arrive at a situation where you may get this error. <!-- 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-59c82c04b59b74b5696b4ce5b6fdb4432432dd7be9e6598c43fe9e4a14c94993","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '--crate-type=lib --edition=2021 -ooutputfile -Zdump-mir-dir=dir' 'thread 'rustc' panicked at 'internal error: entered unreachable code'', 'thread 'rustc' panicked at 'internal error: entered unreachable code'' File: --code: 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-02-12 found 8 bors merge commits in the specified range commit[0] 2023-02-10: Auto merge of - flip1995:clippyup, r=Manishearth commit[1] 2023-02-10: Auto merge of - JulianKnodt:arrayconstval, r=cjgillot commit[2] 2023-02-11: Auto merge of - BoxyUwU:deferredprojectionequality, r=lcnr commit[3] 2023-02-11: Auto merge of - Dylan-DPC:rollup-fkl9swa, r=Dylan-DPC commit[4] 2023-02-11: Auto merge of - petrochenkov:doclink2, r=oli-obk commit[5] 2023-02-11: Auto merge of - the8472:rawvec-simpler-layout, r=thomcc commit[6] 2023-02-11: Auto merge of - matthiaskrgr:rollup-qnn380r, r=matthiaskrgr commit[7] 2023-02-11: Auto merge of - cjgillot:sroa-const, r=oli-obk ERROR: no CI builds available between and within last 167 days maybe ? ping"}
{"_id":"doc-en-rust-f690b1524cefb71b0292504fb4b2e291d373ad2a8482ceb54a934841747b8532","title":"","text":"It looks like that when a local variable is initialized in a loop and dropped in the same loop, the stack local drop flag for that local isn't reinitialized to \"not dropped\" when the loop runs after the first time. Concretely, this test passes on stable and fails on nightly right now: cc\nInterestingly this slight variation on the above code does drop twice as expected:"}
{"_id":"doc-en-rust-0f4e8668cac184ed6117ea88c4c4b1048515a7e5ec6f89bdb47526872e5b0cef","title":"","text":"I tried this code: I expected to see this happen: it compile Instead, this happened: it didnt It most recently worked on Rust 1.60 and this nighty: : searched nightlies: from nightly-2022-04-26 to nightly-2022-04-29 regressed nightly: nightly-2022-04-29 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.3</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nSlightly simplified reproduction: In other words, this isn't specific to .\nSince this has been fixed now and we never received any reports outside of bevy, I'm going to go ahead and retroactively mark this as P-high. I had suggested , but that appears not to have been correct."}
{"_id":"doc-en-rust-085409dcef93908a429af332ac7e4f51617f3e573aa37899e533c49777a5f9ea","title":"","text":"Tracking issue for trailingzeros and leadingzeros for non zero types as introduced by . The feature gate for the issue is . On many architectures, this functions can perform better than trailingzeros/leading_zeros on the underlying integer type, as special handling of zero can be avoided.\nIt seems on my (common) architecture it doesn't give an advantage: : : So the question is: is this NonZero method worth keeping? Are the architectures where it gives a performance advantage common enough?\nbut as you show in your example if you want to make a distributable binary and due to this not set the target-cpu there is a big difference\nThe architecture I'm using is quite standard. A distributable binary could probably use it as \"universal target\". I don't know much common is going to be an instruction like tzcnt in the future. If you think a similar instruction will be sufficiently uncommon then please ignore my comments here :-)\nmerge cc\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.\nstarted to make the stabilization PR but hit a problem I think that constcttz needs to be stabilized for this to be stabilized from //! If an intrinsic is supposed to be used from a with a attribute, //! the intrinsic's attribute must be , too. Such a change should not be done //! without T-lang consulation, because it bakes a feature into the language that cannot be //! replicated in user code without compiler support."}
{"_id":"doc-en-rust-0a396996c5e71e5549afbc67ed4bc7561878e9d205281062d3053330284332cc","title":"","text":"Super easy to implement for anyone interested. The implementation in the RFC is sound, although the new code should be abstracted out into a function that the macro calls for inline and macro-sanity reasons. The function needs to be marked as public/stable, but should otherwise be marked as #[doc(hidden)], as it is not intended to be called directly -- only by the macro.\nWilling to mentor on details.\nI'd like to give it a shot :)\nBy the way: The seems very sparse. If it's okay, I'd expand that a bit while I'm on it, or should that go into a seperate PR?\nYeah, that's totally reasonable to do at the same time!\nGreat! What would be the preferred place where to put the new function? I've it to as for now (currently compiling it)\nSince it's supposed to only be used by the macro (and will be doc(hidden)), it makes sense to me to put it in Putting it in makes sense, too, though.\nhas a section labeled \"Internal methods and functions\" that seemed to fit well."}
{"_id":"doc-en-rust-7d929a55a801b35d30d58d913f2afb0e04998c1d70c5f0cf00e15985806a02d6","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</detailsNOTE: The bug is found by our work-in-progress compiler testing tool Kira, and the test program is reduced/minimized by\nSeems to have regressed in Rust 1.33 based on testing in Godbolt.\nWith only the errors relevant to the ICE:\nI'll fix this.\nFixed in"}
{"_id":"doc-en-rust-db8cf913bad24f6a17680fdd92fc03c63770c583268f75680dff54f333e3f190","title":"","text":"This somehow doesn't occur when putting the function in a non crate, yet I can't find any difference between the version of and this one. () Errors:\nSeems like it panic when the trait is not found: Maybe it can use  instead."}
{"_id":"doc-en-rust-48cee304816ed8068fba74f198865051001db76ca3462cd9612353747a29af8e","title":"","text":"I just encountered this output: We currently mention available fields when the field used isn't found. It would be nice if we peeked at the types for the available fields to see if any of them has any fields (including through deref) of the name we originally wanted. In this case, I would love to see the following output: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI'll work on this. claim\nI was just about to open a PR when I saw that you claimed the issue. It's my fault for not claiming this issue myself obviously, so if you've already been investing time into this the issue its still yours, but if you haven't can I open a PR for this?\nI've done nothing yet as I planned to work on this tomorrow morning, so this is yours :)\nrelease-assignment\nif you're still interested in contributing, it seems to me that might be similar in scope and section of the codebase you could work in.\nThank you."}
{"_id":"doc-en-rust-bc991a8c63d81686bebf07f793f5c69e366692742b1f03c258d8aba8722870bd","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: I expected that the help text would give syntactically correct code, or that there would be no help text. Instead, this happened: The provided code snippet is not valid - it tries to deference the else-block, which is impossible. Better would be to put the inside the else-block. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: Also occurs on stable, 1.50.0. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim I have a fix for this bug + an improvement. Gotta got for now but will submit the PR later today."}
{"_id":"doc-en-rust-a307df6afd7fee0359c06b3ec49e368dd69f57ee370ac4b77c4fed4ee685c190","title":"","text":"The following minimal example causes an internal compiler error. Error in question: rustc version: This error was encountered on stable, but I can confirm that it also occurs on the latest nightly ().\nHasn't the feature gate issue been fixed? :|\nI've removed the nomination and this to the tracking issue for GATs . The current impl is highly incomplete and ICEs are, sadly, expected. Also, I verified that a feature gate is indeed required.\ntriage: P-medium\nI don't know if I get you wrong, but the example above ICEs on stable, beta and nightly without feature gate\noops, looks like I accidentally left the feature gate in there when I tried it out, but it produces the same ICE when it is omitted as well.\nNo, niko edited your question. ping I think you got something wrong there. Can you please clarify that?\nOh, I guess I was indeed incorreect. I tried it on play but didn't notice that, after the \"correct\" error, it goes on to print an ICE.\nWhat about adding the I-nominated tag again?\nI'm not sure why we would nominate this for discussion. Yes, it is an ICE (and an ICE that occurs without the user adding a feature gate), but the message pretty clearly states that you're using an unstable feature. It would be great to fix it so that it issues the error diagnostic without ICEing, but I wouldn't re-prioritize that work above P-medium.\nassigning to self since its a clear annoyance\ntriage: P-medium. (dupe of )\n(the remaining bug, when the feature gate is enabled, is tracked in issue )"}
{"_id":"doc-en-rust-0842aa6993811c0784533326c34ad3125899004b9de3640a800fe5a400389e73","title":"","text":"I tried this code, sorting 30 million random : On this machine: Using the vendored version of from mid 2022 see here I expected to see this happen: Runtime ~1.45s Instead, this happened: Runtime ~2s I bisected the issue down to with . The same happens if you do instead of . So this also affects the current implementation which is very similar to my vendored version.\nDinging into it, I think the relevant code that has this impact is in the function. Which has two blocks of logic one for if the left side is shorter and one if the right side is shorter. Previously both sides generated code that is branchless in terms of jumping based on the comparison result. Now the block handling left side is shorter generates a jump based on the comparison result. LLVM 15: ! LLVM 16: ! This can be fixed in code by using 'proper' branchless code: -This would fix the stdlib, but it would still mean a regression for any other code out there that relies on this.\nI feel like I should attach the usual disclaimer that this kind of optimization can never be considered fully stable, specifically LLVM has various heuristics that affect whether it compiles a segment of code to use a \"branchless\" CMOV-alike or use a jump, however that doesn't mean there's nothing we can do here. label: +A-LLVM +A-codegen +regression-from-stable-to-beta +I-slow\nWG-prioritization assigning priority (). label -I-prioritize +P-low +T-compiler\nout of curiosity. What is the future for a perf regression marked as P-low? Is there any work planned on this? Personally I was surprised that it even generated branchless code in the first place.\nA P-high or P-critical compiler issue means that it will be reviewed regularly by T-compiler until it is resolved, where \"regularly\" is a much higher frequency for P-critical. So a P-low implicitly means \"this isn't so important that we need to keep putting it on the agenda\". Though I should note that periodically, all T-compiler issues do get reviewed and triaged, just on a more irregular basis."}
{"_id":"doc-en-rust-8d546496250b29b405ce72c8edcd287150cbbaa28d35737b98e571fd81beaea2","title":"","text":"Performance work is one of those \"never done\" things so it's rare for it to be high priority in general, which isn't the same as \"no one will work on it\". It just means it would be addressed in a somewhat irregular fashion.\nI'm not sure I understand the difference between \"never done\" and \"no one will work on it\".\n\"Never done\" as in \"never finished\" not \"never worked on\"\nOhh, thanks for clarifying. Anyway from my perspective me and other people I've talked to were surprised this even generated branchless code in the first place, I'd be fine with closing this issue as won't fix.\nsince you have opened a PR (thanks a lot for that!), it makes totally sense to try fixing it, no matter the priority we assign to issues.\nI think the issue can be split into two parts: A) A significant regression in . B) LLVM no longer generating branchless code for a certain pattern. I think A should definitely be fixed, and that's what my PR is for. B however I'd argue doesn't really need fixing, because the code in question was not obviously branchless."}
{"_id":"doc-en-rust-a0bd5701dd4a61aa50c59764e895740c0a5395abea9406f44f3c7b336afb0773","title":"","text":"In the followup discussion on , we discovered that their original problem was because they had chosen a path under their home directory for , but they had not changed the default . So most things installed fine, but they didn't have permission to write . Bootstrap could sanity check this when starting an install, seeing that is writable by the current user but the absolute is not. (A relative goes under , which should be fine.) This should also take into account as a further prefix on all installation paths.\nI have just updated to version 1.71.0, and now I'm receiving the terminal warning: In my previous setup, I the line to my file.\nyeah, made that effectively . That was reverted in , and now proposed for stable and beta backports. So you could add for now, but it will be going back to the way it was."}
{"_id":"doc-en-rust-f2ca5f3791d943e96ab8217cb0a49e57220112d34cd166ee35ef8468d6c1d242","title":"","text":"I was working on making a run-make test today for a particular thumb target. While looking over how we do this elsewhere, I found this bit of code: From my local testing, it seems like having multiple lines of this form has the net effect of making the test a no-op that does not test anything: since a target matching line 13 will not match line 14, and vice versa, there are no targets that can run on this test. We should either revert the portion of the commit that did this: or figure out some other way to express the desired property here (or change the semantics of when multiple targets are provided to make it gather all such targets up in a set before doing the check for membership... but I am wary of making such a change since doing it right would require differentiating e.g. processor target vs OS target, for example...)\nAlso, It looks like there may be other instances of the same mistake elsewhere in the test suite, such as in:\nOof, not good. It shouldn't be hard to make rustbuild outright reject this scenario though.\nFurther effort on has led me to conclude that these lines do not work at all, at least not for cross-compilation."}
{"_id":"doc-en-rust-756c6a538375a62e2ee89fff43d53ba74e2de8ec478d83102e0906cd85c2416e","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: always panic Instead, this happened: only -Zmir-opt-level=2 panic For mir-opt-level 0, 1 and 3, they all normally return <!-- If 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 --\nequals , so I think the panic case is incorrect?\nYeah, I think so.\nLooks like it's JumpThreading that incorrectly removes the condition\nI managed to create an example without panic, just wrong value\nMost likely\nha, I found the bug. We're optimizing incorrectly in the jump threading code. Right now it's only written to handle bool correctly. I'll put up a fix claim"}
{"_id":"doc-en-rust-dafd2920ba43b58ad54539303c7552eb922492a8ce202284909e7cf099e4b1e6","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"}
{"_id":"doc-en-rust-d0757f5a8271c276c1bd6c6b7fbdbb77aef77b04e3f124833572ad997be77bf8","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. --produces an ICE for the code given below. This code should produce an error (the implementation is missing associated items). (UPDATED: Here's MCVE: ) <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: Error also occurs 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\nThanks! Further minimized:\nAssigning as and removing .\nDon't know the cause yet, but if you remove the keyword or the operator, then you get this error: My hunch is that somehow, lacking those items, the type of is coming up with something that doesn't implement the expected traits -- I would bet that we are getting an , based on some of the output at the end. Perhaps some of the logic in MIR is failing as a result. The actual ICE location though isn't that illuminating:\nI did some digging here. The source of the panic is here, during HAIR construction: In this case, the binding below is of the error type (meaning type check for it failed). By replacing the binding with `` we prevent a local from being created for it, which means that when we try to generate code that reads the local we get a panic . I'm not sure what the correct fix is here. Replacing the binding with was done to prevent other ICEs, but we can't generate valid MIR without the local info. More fundamentally: We're building MIR during typeck because this is an async fn. In the past we probably never would have gotten to this stage. Backtrace: <details</details"}
{"_id":"doc-en-rust-de849dda95f52b53914b5721b16c492b655b87e70c468c569d87fbda3105631a","title":"","text":"When using async closures, rust since around 1.80 fails to infer parameter type in most scenarios. I expected to see this happen: All options used to work in past versions of rust Instead, this happened: Without explicit type hint it fails It used to work in the past, around 1.79\nWe don't typically mark nightly features with labels, so I'm removing those. Are you certain this regressed in 1.80? This should have regressed in , when I reimplemented async closures completely.\nI am not 100% sure when it happened. I used to work with 1.7x a couple of months ago. Then I left my project for a moment. When I came back, after updating to 1.81 it no longer works. IIRC before leaving it was around 1.79, but I'm not sure.\nThis limitation to async closure signature inference has to do with the fact that the combinators you're using (e.g. ) take regular trait bounds. Is there a particular reason you're using async closures here? They're really not gaining you anything other than a dependency on the nightly compiler.\nI posted a minimal example, indeed async does not make much sense here, but in project I work on it does. As a workaround I've just annotated parameters with original types, but I still believe this is a bug.\nThis indeed regressed in .\nWhile the problem from first message in issue seems to be fixed, there are still cases when this fails. One of examples is when using instead of , when closure is expected to return : Should I open new issue, or this one will be reopened?\nPlease open a new issue, since it's likely a different root cause"}
{"_id":"doc-en-rust-d2696cc37cdbedb80da25c591152044f2e8391cf31101bcf1942427d4cba1626","title":"","text":"clauses on associated types don't work yet so should be feature gated, presumably with . cc . Happens on versions = 1.24"}
{"_id":"doc-en-rust-f31e389170b25741411b93e85e658b2ad8e4a2a2e6b80563232e2387d740f3ad","title":"","text":"I'm seeing an internal compiler error on the following input (found by ): The error happens on and but not on .\ntriage : P-medium, removing nomination, adding needs-bisect.\n(the bisection here would be entirely automatable if were addressed.)\nBisected roughly: ICE occurred from but not panicked, panicked from\nin particular looks suspicious. cc\nPre-, we return early with an error here: Post-, in the corresponding code happens in a call to : and the parser \"recovers\" from the error encountered in , allowing this line to be reached:\nI opened , which takes the stance that is no longer appropriate here. It's possible that there's a better fix that changes the way works, but that would require a deeper expertise of how these things are supposed to work than I currently have."}
{"_id":"doc-en-rust-9c8949d388a9942516db86252dec2dfb897b9659b1fdca964fe617c7369dd448","title":"","text":"While trying to figure out what the attribute did, I ran across this line of code. Near as I can tell, the reference to here doesn't do anything, and can be removed for clarity.\nMarking as an easy issue since it seems that removing that line is all that would need to be done here, and then if CI passes, great, if not, then we shouldn't remove it. Willing to mentor as well.\nI take this up\nclose?"}
{"_id":"doc-en-rust-8e5cfb6988ed7e1692af3b99f6a32dfb23f144534166ed1c5c1c1042a808dc43","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 minimal triggering case seems to impl a trait that isn't visible from the location it ends up. edit: this turns out not to require macros at all. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: This also occurs in nightly (), but not in stable (which provides the correct complaint that is not publicly re-exported) <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nsearched nightlies: from nightly-2023-11-11 to nightly-2023-12-28 regressed nightly: nightly-2023-12-19 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.7</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\n0x7f6adfe7f645 - core::panicking::panic fmt::hcc at /rustc/ /library/core 72:14 180 x - <rustc resolve[]::late ::LateResolutionVisitor as rustcast[]::visit::Visitor::visititem 19: 0x7f6adee2d7ff - <rustcresolve[]::Resolver::resolvecrate ::{closure} 20: 0x7f6adee2ad1a - <rustcresolve[]::Resolver::resolvecrate 21: 0x7f6adeeb6d72 - rustcinterface[]::passes::resolverforlowering 22: 0x7f6adeeb5e2b - rustcqueryimpl[]::plumbing::rustbeginshortbacktrace::<rustcqueryimpl[]::queryimpl::resolverforlowering::dynamicquery::{closure}::{closure},"}
{"_id":"doc-en-rust-71e7458504b5fce5e43cf3f1535504eed30918b4c3a9049912f4a8419f2d901a","title":"","text":"rustcmiddle[]::query::erase::Erased<[u8; 8usize]23: 0x7f6adef1f8ec - rustcquerysystem[]: :query::plumbing::tryexecutequery::<rustcquery impl[]::DynamicConfig<rustcquerysystem[]::query::caches::SingleCache<rustcmiddle[]::query::erase::Erased<[u8; 8usize], false, false, false, rustcqueryimpl[]::plumbing::QueryCtxt, true24: 0x7f6adef1eff3 - rustcqueryimpl[]::queryimpl::resolverforlowering::getqueryincr::rustendshortbacktrace 25: 0x7f6aded0bab3 - rustcinterface[]::interface::runcompiler::<core[]::result::Result<(), rustcspan[]::ErrorGuaranteed, rustcdriverimpl[]::runcompiler::{closure}::{closure} 26: 0x7f6adee3b25b - std[]::syscommon::backtrace::rustbeginshortbacktrace::<rustcinterface[]::util::runinthreadwithglobals<rustcinterface[]::interface::runcompiler<core[]::result::Result<(), rustcspan[]::ErrorGuaranteed, rustcdriverimpl[]::runcompiler::{closure}::{closure}, core[]::result::Result<(), rustcspan[]::ErrorGuaranteed::{closure}::{closure}, core[]::result::Result<(), rustcspan[]::ErrorGuaranteed27: 0x7f6adee3b0b9 - <<std[]::thread::Builder::spawnunchecked<rustcinterface[]::util::runinthreadwithglobals<rustcinterface[]::interface::runcompiler<core[]::result::Result<(), rustcspan[]::ErrorGuaranteed, rustcdriverimpl[]::runcompiler::{closure}::{closure}, core[]::result::Result<(), rustcspan[]::ErrorGuaranteed::{closure}::{closure}, core[]::result::Result<(), rustcspan[]::ErrorGuaranteed::{closure} as core[]::ops::function::FnOnce<()::callonce::{shim:vtable} 28: 0x7f6adfe3d8e5 - <alloc::boxed::Box<F,"}
{"_id":"doc-en-rust-d57947fd37a2380d989893e16e2040584f50321ec93296f960f89bed501f56fd","title":"","text":"Aas core::ops::function::FnOnce<Args::callonce::h5d7c8f150ab9c84c at 29: 0x7f6adfe3d8e5 - <alloc::boxed::Box<F,Aas core::ops::function::FnOnce<Args::callonce::h570d5b005c242c15 at 30: 0x7f6adfe3d8e5 - std::sys::unix::thread::Thread::new::threadstart::h36b0a20c0b2361ad at 31: 0x7f6ad9e97ada - <unknown32: 0x7f6ad9f2847c - <unknown33: 0x0 - <unknownerror: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: rustc 1.76.0-beta.1 ( 2023-12-21) running on x8664-unknown-linux-gnu note: compiler flags: --crate-type bin -C embed-bitcode=no -C debuginfo=2 -C incremental=[REDACTED] note: some of the compiler flags provided by cargo are hidden query stack during panic: [resolverfor_lowering] getting the resolver for lowering end of query stack\nThat is line 18 to 33\nWG-prioritization assigning priority (). label -I-prioritize +P-medium\nAn interesting issue, claim\ninteresting that the crash also doesn't happen if we qualify the trait with instead of the crate's name.\nThe is interpreted as referring to an external crate, whereas not\nright; i'm assuming it hits a different resolver codepath, despite both working the same if the referred ident is public. thanks for the quick fix!"}
{"_id":"doc-en-rust-7bdc2a1076403b14b3b7ffe6e2607f626dc344c6eab1abe343328494516dcb5c","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'expected region for ('a//0) but found Type(&'{erased} mut FooImpl<'{erased}, '{erased}, T/) when instantiating args=[&'{erased} mut FooImpl<'{erased}, '{erased}, T/, '?27, ?2t, Closure(DefId(0:22 ~ a[a197]::{impl}::foo::{closure}), ['{erased}, '{erased}, T/, i32, Binder(fn((&ReLateParam(DefId(0:22 ~ a[a197]::{impl}::foo::{closure}), BrAnon) mut FooImpl<'{erased}, '{erased}, T/,)), []), ()])]'', 'thread 'rustc' panicked at 'expected region for ('a//0) but found Type(&'{erased} mut FooImpl<'{erased}, '{erased}, T/) when instantiating args=[&'{erased} mut FooImpl<'{erased}, '{erased}, T/, '?27, ?2t, Closure(DefId(0:22 ~ a[a197]::{impl}::foo::{closure}), ['{erased}, '{erased}, T/, i32, Binder(fn((&ReLateParam(DefId(0:22 ~ a[a197]::{impl}::foo::{closure}), BrAnon) mut FooImpl<'{erased}, '{erased}, T/,)), []), ()])]'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [mirborrowck] borrow-checking [mirborrowck] borrow-checking --\nICEs on nightly and beta, but not on stable. Minimized further: <details<summaryProgram output</summary</details\nThe ICE is another one from , cc\nStill reproduces on 1.81.0-nightly (2024-06-13 ) -E-needs-test\nI'll look into it later today."}
{"_id":"doc-en-rust-ea6c2f742466aca108571f2c909618d07c310be9bf346fc494cfcf755c7dcffc","title":"","text":": <details<summary<strongBacktrace</strong</summary<p</p</details\nThis looks to be a recent regression from cc and is on beta 1.79, but is just in diagnostics."}
{"_id":"doc-en-rust-42d8b055d45d294a0a90315e21edde8f76f35ec5c44c40b7b02076d7b468fd4f","title":"","text":"<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p may be related, but I don't think this is the same bug because the above ICEs with nightly-2020-05-29.\ncc"}
{"_id":"doc-en-rust-ff28f028756d93367128a9da007f92e308ef4bdb96d8ee0107e54e9360af32f2","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 --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nRegression in nightly-2023-06-03 Regression in Regression in ?\nThis is fixed by .\nassign"}
{"_id":"doc-en-rust-cd356b80efe8963569b705c0d082e39ab100fdda7683d49f27a524f808e2b4f1","title":"","text":"Tracking issue for: rust-lang/rfcs Functional record update does not mark the source as consumed, even if does not implement Copy. This means that e.g. the source's destructor will eventually be run, so the following code prints :\nNote that, as discovered, you can also explicitly consume , also allowing code like:\n:bomb:\nIs legal, even if all members are private? It's a bit surprising\nIt is. There's the potentially-useful case where some of the members are private, and FRU allows you to update the public ones. Of course it should consume the source even then.\nP-backcompat-lang, 1.0 beta\nIn my opinion the problem here is the privacy violation. The idea is that is expanded to and so forth. In this case, that does not trigger a move, because the types of those fields are . I think that part is acting as expected. What is surprising is that one can do this from outside the module.\nThat was (but my favored solution isn't minor).\nWhen I initially saw this problem, I did not see it as a privacy violation, for the (obvious?) reason that since no private members of had been mentioned in the code , the client module is not breaking any abstraction introduced by privacy. I think this line of thinking is analogous to outline of the useful case where FRU allows one to update the public members of a type and silently move the private ones as well, via . This is useful for the case where the author of wants to reserve the right to add new private members to while still allowing for clients to use the convenient FRU syntax. I originally was going to try to explain my point of view via analogy with something from hygienic macros: If I were to define (and export) a macro within 's defining module: then it should, in principle, not be a privacy violation to use from client code outside 's defining module. (That is, in principle, hygiene should allow macros to expose controlled access to private internals.) Then I realized the crucial problem with that kind of analogy: is something that the designer of has to choose to put into the module; i.e., it is opt-in. But currently in Rust, FRU is not opt-in; its not even something you can opt out of."}
{"_id":"doc-en-rust-d6f89ff452205249e804ee67896c49d22c052f99387d1c0f11af3b93dd1a3665","title":"","text":"Any struct automatically is given support for it, whether it be appropriate for that struct or not. And that seems wrong, at least given examples like the one provided here in . This latter point, that providing support for FRU should not be something that is silently attached to a type like , seems somewhat in line with the thinking given in . But I am also pretty sure we cannot adopt anything of the scope given in that draft. (Still, maybe there's a hint of solution embedded within, in the sense of having some way of marking a type as data vs abstract; see final two bullet points below.) So, as I see it, we can either: out a way to support the point-of-view outlined here in the description for , in that should somehow be treated as consuming . Such a change seems like it would be quite subtle, since we would need to have some way of expressing that code like is sound, even if the types of the fields and are consumed by their respective and methods. (In other words, need to consume , yet somehow not completely consume it. Maybe there's a way to think of it as consuming \"whatever is left of the type\", I do not know.) Advantages: This would address the bug as described by the issue author, and would not break any code that was not already broken. Drawbacks: It is not clear what the semantics are for this form (in other words: the phrase \"would not break any code\" above is only true if you first accept that this hypothesized semantics exists). Also, there may not be time to do this properly for 1.0. , try to adopt a data/abstract-type distinction along the lines of the one in draft RFC. (I'm not going to write Advantages/Drawbacks for this; I think we clearly do not have time to do it that way for 1.0) , change FRU into a non-hygienic expansion into the record construction form with all fields listed, in the sense that is synonymous with and subject to privacy checks. Advantages: Seems really simple to implement, and is consistent with at least one core team member's mental model of FRU. Drawbacks: If we did this, then code like the example above would break."}
{"_id":"doc-en-rust-052ce01de26b08a8f737abdfb24caf536f7787a9ed0ef876d1b88ac232477464","title":"","text":", let FRU keep its current hygienic (aka \"privacy violating\") semantics, but also make FRU something one must opt-in to support on a type. E.g. make a builtin trait that a struct must implement in order to be usable with FRU. (Or maybe its an attribute you attach to the item.) Advantages: Also seems really simple to implement (in the language). Accommodates users of FRU for the example. Drawbacks: If we did this, it would impose a burden on all code today that makes use of FRU, since they would have to start implementing . Thus, not simple to implement for the libraries and the overall ecosystem. , a hybrid between the previous two bullet-points: By default, treat FRU as non-hygienic expansion, but add a builtin trait that one can opt-into to get the hygienic (aka \"privacy violating\") semantics. As a bonus, perhaps implementing on a struct would also imply implementing on that struct, which seems like it would basically give us something very similar to the semantics desired by (Or, again, maybe its an attribute you attach to the item. This detail does not particularly matter to me.) Advantage: While this is obviously more complicated than the previous two bullet-points, it has the advantage that it has a staged landing strategy: We could just_ implement the change to FRU to be non-hygienic expansion for 1.0 beta. We could add at an arbitrary point in the future; it would not have to be in the 1.0 release. Drawback: People have claimed that some of my past proposals were a bit ... baroque. I imagine this one is no exception. :) (In other words, this semantics is a little complicated to explain to a newcomer.)\nI don't want to make a big fuss about it, but I do want to note, again, that our \"deadlines\" are entirely self-imposed, and that under these circumstances \"we don't have time\" is slightly odd, because we can make time, any time we want. The blanket refusal to even contemplate doing that - even in light of new information - and to weigh the tradeoffs on their own merits is something I still don't really understand."}
{"_id":"doc-en-rust-f88caec2557592d4606dad39cd734d5f1a3e33cd1274c6919ee6120c35705a54","title":"","text":"That out of the way, an additional possibility, let's call it 6., for list: We could just make the \"abstract type\" vs. \"data type\" distinction based on \"does or doesn't the type have a private field\". This doesn't entirely fill me with satisfaction (as with \"worse is better\" solutions in general), with specific drawbacks being that it doesn't extend cleanly to the nullary case (no fields at all), and that in terms of UX a change of semantics based on the presence or absence of a private field may be unexpected, but on the plus side, it's simpler, and would, I think, work.\nSure, hypothetical show-stopper issues could cause us to revisit our self-imposed schedule. I personally don't think that this issue, on its own at least, provides sufficient motivation for schedule revision. I admit that your draft RFC seems like it addresses a host of issues, so maybe all of them taken in unison would be a different story. (But then again, that's not even my call to make.)\nThere were a couple more options that I should have put on the list, for completeness, but overlooked. 6 note, the \"has any private fields ==abstract-type; all public fields ==data-type\", is one of them. This would (probably) be less work than adopting the draft RFC in full, but I am not sure what the other Advantages/Disadvantages are. I invite others to write an Advantages/Drawbacks for this approach (perhaps in an RFC PR). 7 We could add a way for a struct to opt-out of FRU support entirely. So in this approach, one would attach the appropriate attribute to , , etc. Advantages: won't break any existing code Drawbacks: Seems quite fragile; we may be good about auditing our own stdlib, but clients who are not aware of the attribute may inadvertently expose themselves to the same bug that currently plagues .\nAlso, I just wanted to mention: when I wrote my comment 6 hours ago, I came to the keyboard thinking that the FRU support for adding new private fields to and having still work was an important use case. But after some reflection in the hours since, supporting that use case does not seem as important to me."}
{"_id":"doc-en-rust-af18126ee9950e4e8ddf5f7113df149b986b16d1a95a5eb29bbef32e79a631f3","title":"","text":"Here is why: It is relatively easy for a developer who wants to provide that sort of extensible abstraction can still do it, by factoring the type into a all-public front-end with a single public field that holds the all-private back-end, like so: So, given that there exists a reasonable pattern to bring back usable FRU even under the option \"(3.) change FRU into a non-hygienic expansion into the record construction form with all fields listed, in the sense that is synonymous with and subject to privacy checks.\", I would not object to us adopting (3.) aka solution.\nI think that \"has any private field\" is a decent way to handle abstractness (you can always add a private unit field). On the other hand, Rust supports trait bounds of types – these should handle roles just fine – you shouldn't be able to coerce past a trait bound. By the way, this is somewhat subtle, because coercing to is wrong (as it leaks memory – it coerces past the implicit bound), but coercing to is fine (as the bound isn't used by ). However, this isn't a property of – you still can't coerce to – so we probably want a relatively-sophisticated way to occasionally ignore roles.\nI mean, Rust already has a mechanism for ensuring representation-abstraction – private fields – which are semantic (they are handled after type-checking, we probably want to handle them during it, but they definitely aren't handled syntactically or during resolution). It is just that FRU currently accesses them improperly. Also, it doesn't have much to do with e.g. roles – is an abstract type, but it doesn't use any bound on . only uses the implicit bound. A for data-only types would be nice, through.\nAnother alternative came to me while I was drafting an RFC about this. (But its an alternative that I do not particularly like.) 8a Instead of making \"has any private fields\" the thing that makes FRU unavailable, instead make the rule be \"has all private fields.\" Thus types like and will not be subject to the vulnerability outlined here. Adding a single field to an otherwise private struct is what changes the nature of a struct with respect to abstraction and FRU, rather than adding a single non- field to an otherwise public struct."}
{"_id":"doc-en-rust-2970bb6c7ef2c53faa928bc9972b6000d9bf53fad0a8ad5bc68188bb06d21ee9","title":"","text":"8b, which is so similar to 8a that I gave them both the same numeral: Outlaw the trivial FRU form . That is, to use FRU, you have to use at least one field in the constructing expression. Again, this implies that types like and will not be subject to the vulnerability outlined here. (This may be a decent change to make to the language regardless of whatever else happens on this ticket; the only argument in favor of keeping support for such a trivial form is maybe for supporting certain macro-expansions. But fully-general macro-authors already have to tread very carefully around corner cases on structs, due to issues like the empty braces problem (see )\nThat would leave the vulnerability intact in the case where the type has both public fields and private fields, the fact that no such type currently exists in the standard library notwithstanding (just as a very artificial demonstration, consider a with ).\nyep. Library authors would have to factor their structures very carefully. (I described the drawback you mention in the RFC I posted shortly after you wrote your comment, though I did not include the detail of having the private fields be , which does seem like it could make the situation all the more subtle. Not insurmountable, but a definite drawback.) Just to be clear, I'm not saying I prefer (8a) or (8b); I'm just trying to be complete in my exploration of the solution space.\nRepurposed as the tracking issue for rust-lang/rfcs\nI'll just go snag"}
{"_id":"doc-en-rust-b2c0fd7f27e207b0aeb3b1757d5a85452cbd443db2c879cf38d9d043cb3bb69e","title":"","text":"Updated the toolstate repository at https://rust-lang- currently does not seem to work, see e.g. To \"tool failed to build\"-issues are being created, either. remarked that the error . Cc"}
{"_id":"doc-en-rust-6a9ca08a118c196a2c1d1c0cb70184067aff2d94a2b9826a310909307d2ad1db","title":"","text":"I found that current rustc 1.13.0-nightly can't compile'Rust by Example - 8.2.5 As output parameters' code, both on my linux pc and . I tried this code: see Executing code above on Rust Playground produces the message below when selecting nightly. ( but stable and beta do not produce this error). error: linking with failed: exit code: 1 | = note: \"cc\" \"-Wl,--as-needed\" \"-Wl,-z,noexecstack\" \"-m64\" \"-L\" \"/usr/local/lib/rustlib/x8664-unknown-linux-gnu/lib\" \"./out.0.o\" \"-o\" \"./out\" \"-Wl,--gc-sections\" \"-pie\" \"-nodefaultlibs\" \"-L\" \"/usr/local/lib/rustlib/x8664-unknown-linux-gnu/lib\" \"-Wl,-Bstatic\" \"-Wl,-Bdynamic\" \"/usr/local/lib/rustlib/x8664-unknown-linux-gnu/lib/libstd-\" \"/usr/local/lib/rustlib/x8664-unknown-linux-gnu/lib/libpanicunwind-\" \"/usr/local/lib/rustlib/x8664-unknown-linux-gnu/lib/libunwind-\" \"/usr/local/lib/rustlib/x8664-unknown-linux-gnu/lib/librand-\" \"/usr/local/lib/rustlib/x8664-unknown-linux-gnu/lib/libcollections-\" \"/usr/local/lib/rustlib/x8664-unknown-linux-gnu/lib/librustcunicode-\" \"/usr/local/lib/rustlib/x8664-unknown-linux-gnu/lib/liballoc-\" \"/usr/local/lib/rustlib/x8664-unknown-linux-gnu/lib/liballocjemalloc-\" \"/usr/local/lib/rustlib/x8664-unknown-linux-gnu/lib/liblibc-\" \"/usr/local/lib/rustlib/x8664-unknown-linux-gnu/lib/libcore-\" \"-l\" \"dl\" \"-l\" \"pthread\" \"-l\" \"gccs\" \"-l\" \"pthread\" \"-l\" \"c\" \"-l\" \"m\" \"-l\" \"rt\" \"-l\" \"util\" \"-l\" \"compiler-rt\" = note: ./out.0.o: In function drop::hf3564cae7b79f1cb': (.text."}
{"_id":"doc-en-rust-924fb4458b97ee5f3d68a84b0d159e617d21a14bfd48b11b7fd17dec83692d06","title":"","text":"ZN4drop17hf3564cae7b79f1cbE+0xd): undefined reference toLTGTasGT$::drop::h4c07c16183524d21' ./out.0.o: In function drop::hc5f0e028c3876d25': (.text.ZN4drop17hc5f0e028c3876d25E+0xd): undefined reference toLTGTasGT$::drop::h7a8bb753832b1af2' collect2: error: ld returned 1 exit status error: aborting due to previous error Compilation failed. This happens on my Linux Laptop pc as well. This is my laptop's rustc version(installing current latest) . : rustc 1.13.0-nightly ( 2016-08-25) binary: rustc commit-hash: commit-date: 2016-08-25 host: x86_64-unknown-linux-gnu release: 1.13.0-nightly\nNominating since this appears to be a regression.\nis still good, does not exist and fails. . Reduced:\nThis may be a related to . Edit: not a duplicate I think, since was introduced in a different nightly.\nRunning with the above sample and leads to an ICE in printing a log message\nThis is from the removal of old trans. We should've been covered by on-demand drop glue generation still, though. cc\nLooking at the IR - the missing methods are d, and called from drop methods taking e.g.\nOh, this is bad. The collector needs to know user definitions being instantiated ahead of time (including impls), and these can be used from drop glue which is not guaranteedly known ahead of time. We might need to temporarily detect the shim'd cases in the collector and trigger drop glue generation. cc\nI'm looking into a short-term fix right now.\nyay! Thanks"}
{"_id":"doc-en-rust-83912a1875afe828c0adb5dc1fb220ceb28e00ea7047cf59e211247f039ccf3d","title":"","text":"Trying to build  0.2.5 with latest nightly results in an ICE. Bisected the regression to , cc I have tried to minimize it. This still requires 0.3, I'm not sure how to minimize if further. <!-- If 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\nSeems like a duplicate of\nI don't think that is related, neither the error matches nor is it a recent regression. Did you link the wrong issue? fixes this ICE\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-high\nStill needs a backport\n(assigning self to ensure backport happens.)\nAlso seen in the latest (): zebra-consensus: https://crater- warp v0.3.1: https://crater- linkerd: https://crater- Along with a number of others.\nBackport () was merged."}
{"_id":"doc-en-rust-577b2d31afb6271cb2335741b57a534d2c858d544dfcacd2268b43d5423d6d50","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: cannot convert to a region vid', 'error: internal compiler error: cannot convert to a region vid' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [mirborrowck] borrow-checking [analysis] running analysis passes on this crate --\ncc"}
{"_id":"doc-en-rust-66fc9963abdafc9e6929ffd62b615687417c9bbafc1ca99f5237423c8cbe5f5c","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\nIs this a duplicate of\ni think so\nI wish there were a \"close as duplidate\" for this. Ah well.\nthere is actually, if you click the drop down on the close button\nHunh, they mean to include that in \"not planned\". Strange.\nthe \"duplicate\" issue is closed but this is still failing.\nAlso ive found that even if you do this without nesting the impl trait it still ICE's.\nAnd if you do it succeeds."}
{"_id":"doc-en-rust-a0ccb76a6e60f5a57f49822c16e14a4158fd6807515502bfbce2a615c588e5c2","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. --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.57.0 ( 2021-11-29) running on x8664-unknown-linux-gnu note: compiler flags: -C embed-bitcode=no -C debuginfo=2 -C incremental --crate-type bin note: some of the compiler flags provided by cargo are hidden query stack during panic: end of query stack <!-- If 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 --<!-- TRIAGEBOT_END --\nreduced:\nMinimized this a tiny bit further, and I have a detailed explanation why this occurs: So this bug first starts going wrong in late resolution. Specifically, , we define the as a binding when we see the second element (ident subpattern) of the slice pattern, and then bind it later when we walk thru the (expression!) in the first slice pattern element. Essentially, since we treat as being defined here: and then resolve that as the path for we reach a situation where we expect a variable to have been defined before it has been lowered in HIR, which leads to the ICE later on, since we expect to have lowered that path element.\nWonder how difficult it would be to make have subpatterns instead of subexpressions... edit: wouldn't help, see below..\nActually, I don't think fixing this just for ranges is sufficient. I can reproduce this same issue with this: Maybe I can just delay this panic as a span bug, since we're always gonna error out anyways. I think I would ideally like to fix this by making sure we separate bindings in patterns from affecting resolution for expressions in patterns. edit: Ended up fixing it the right way.\nclaim"}
{"_id":"doc-en-rust-1e7639d323e44931dc05aa7e023f1372448209a69239fe00cbda3db07686f887","title":"","text":"The commit a check that stars firing due to the changes to the default target layouts in LLVM 18 ():\nHaving this issue on as well: Why it's trying to compile for a 32-bit target is clearly beyond me because I'm using an entirely 64-bit host ― since happens to be the author of the crate this is failing on (namely, the 32-bit BIOS version of the bootloader crate which I explicitly avoid depending on for my intendedly UEFI-only kernel), pinging him for assistance.\nI think this issue thread is about some failing tests in the Rust repo. Your issue seems to be specific to the crate, which required some updates to the custom targets it is using. I published a new version already, which should fix the issue. If you still have issues with the crate after a , please open an issue in the repository."}
{"_id":"doc-en-rust-d380ca66a3c478ea98f8da700dbf73638e54c0836be0e8e46532c0dbb72351f3","title":"","text":"I tried this code: I expected to see this happen: The reference is aligned Instead, this happened: : label I-unsound A-mir\nWe have a pass to add moves for drops in packed structs, but it doesn't fire in this case. That's because there's a bug - this computation cannot just take into account the innermost field, it needs to compute a minimum of some sort.\nis this a regression? What did you exactly expected the output to be? (I'd like to run a bisection). thanks.\nThis was right in . Getting a consistent reproduction of this is slightly difficult because the reference might happen to align correctly by accident. In other words, the fact that the example above prints a pointer that is not 2-aligned means that something is certainly wrong. However, if the address were to be 2-aligned that could either be because the bug is fixed or because we happened to get lucky. The consistent way to check this is by looking at . In 1.52.0 the MIR contains which is correct (the move ensures that the resulting place is aligned) while 1.53.0 contains Note that there is no move.\nWG-prioritization assigning priority (). label -I-prioritize +P-high E-needs-bisection\nI have run a bisection with on your . The bisection could not pinpoint a single commit, maybe it sinked into a rollup merge. But if it helps, the regression should be in and coming from one of these PRs do you see in any of those a possible culprit? (I don't have the context to)\nYeah, it's , cc\nNot sure how would have an effect here, it should be a NOP for with . Looks like something else is amiss as well and that PR surfaced the bug? Where is the logic that moves packed structs to a new place before dropping implemented? That's odd, I would have expected this to be inside ... after all calling on a packed struct also has to do this move. Why does MIR building adjust the caller to satisfy a requirement that the callee should be responsible for?\nthe pass is called or something like that."}
{"_id":"doc-en-rust-68d7d02aab47f0ccb4315d63eeee38030b338c848906e6471b100c61288b127b","title":"","text":"And this can't take place inside the callee because the callee receives a , and if that reference is unaligned then UB has already occurred and there's nothing the callee can do to fix things anymore\ntakes a raw pointer, so it could very well be the place where the packed struct alignment trouble is handled. And IMO it'd be a much more natural place than doing this by transforming caller MIR.\nI don't understand the suggestion. The example above never calls for a packed struct. The offending drop in the MIR in the example above is . The type of that place is - but if were to be responsible for moving, then we would need to emit a move in literally every drop shim for a non-trivial alignment type.\nOh I see, I didn't quite read the example correctly. The problematic drop is the one that happens on field assignment, and we know it's a packed field because of the path we are accessing it with. EDIT: no wait this makes no sense. Now I am confused by your comment.\nNo what I just said makes no sense. What happens is that this is a partial drop -- one field has been moved out () and then the logic for dropping the remaining fields seems to be wrong. So is relevant because it changed . And it looks like somehow the change is wrong; here is also despite the reference being unaligned.\nshould fix this."}
{"_id":"doc-en-rust-10b7f709e80a1370173ae0603171431b9a9fd0b23a8385ea3f5bb3aa88a45531","title":"","text":"PRs are bouncing due to test timeouts. Nothing has landed since cc\nVery, very unfortunately, just landed. This means that the breakage is not unconditional.\nSegfault!\nhad also been reporting segfaults on master.\nI got a segfault on\nWhat is causing this?\nWeird, seemed to make it through.\nThis appears to be because of a channel deadlock. Investigating now.\nFixed the deadlock, investigating the segfault now."}
{"_id":"doc-en-rust-1cadb871981fa33e195ab1398ce84ed497353dd5701ac299c8824236d27c9763","title":"","text":"The following code compiles: Nominating for 1.0, P-backcompat-lang. I may well just fix this along with , since the solution is likely going to be similar to what pointed out, but I want to get it on the radar.\nHmm, OK. So the code does attempt to handle this, but I don't know if it is handled in the right way. Specifically, it creates fresh region variables for each region and checks to see whether they unify. The trouble is that does unify with —it unifies if and only if and are the same region. But this is precisely what claimed to be a problem in . So I'm not sure what the right thing is to do here.\nI'm going to assign to because I'm blocked on his opinion on what to do here.\nAssigning P-backcompat-lang, 1.0.\nRight thing to do is to use .\nArgh. The right fix is to substitute some skolemized lifetimes in for the early bound regions before doing the unification rather than fresh variables.\nActually I think the problem is that we're just not calling on the inference context"}
{"_id":"doc-en-rust-f966b13242129b3fd386e19fbd758f692b68d67fd30fba87fc516c8b16bf1063","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. --Example code: In rustc 1.67 stable this generates a number of moves (I suppose for calling convention?) that I don't think need to be there, especially when inlining: See While this is a pretty pointless example, this comes up in situations where you might want to convert a tuple of slices into a struct of slices in order to assign names to the tuple members.\nLLVM should probably be able to elide the below and pass the original pointer. label +A-llvm +I-slow\nThis seems to be resolved on current nightly by & Thanks :tada: (I'm not so sure about an incoming inherent problem on alignment attribute)\nFixed as part of the LLVM 17 update (), needs codegen test.\nMaking the sum a little more vague than the above code prevents the removal of memcpy. Edit: It seems like not so, precisely, the above argument is a function pointer, not a closure, and I now think function pointers never capture any variables (because of ?, ). So is this another missing opportunity?\nYes, the removal is only allowed in the original example, because the called function is known. It does not work with an unknown function due to missing . Note that the is on the by-value argument of , not the by-reference argument of the function pointer .\nThat sounds reasonable. Thanks! So, in this case, if the assumption that the function pointer never captures the argument was correct, missing attribution opportunities for the callbase?\nI don't think there is any missing attribution opportunity here. In your example, if is nocapture, then that does not imply anything about being nocapture (it's a completely different object). Even if you directly passed through the argument to the call (without intermediate memcpy to alloca), inferring nocapture is still not straightforward, because allows interior captures (i.e. it's possible to capture the pointer within the function, as long as it does not stay captured after the function returns).\n(Edit: Now I think that on case, capturing in LLVM might happen. Thanks!"}
{"_id":"doc-en-rust-2ccc646c7f0e6c17a55f593504c3124b11a8dc153ad606c6e758ef0bf7a7cf75","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: <!-- 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] - Stabilized traits necessary to obtain [x] - Added ASCII methods on [x] Final commenting period (FCP) [x] - 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.\nJust needed to manipulate paths on windows -- I need to lower case driver letter, -.\nCurrently, SQLx contains The UTF-8 check that is included in there, while not a problem in practice, seems pointless. Changing to lands me here because of the ."}
{"_id":"doc-en-rust-200310f6b3d7c947b20f3f48363144a6486f501860d937bb3bd606aa1fa8c553","title":"","text":"Also, if somebody did a similar thing with instead of , the version could drop that and would then be a bit less noisy.\nis a stabilization PR. Since lib team wants to do fcp in the tracking issue. could you start one ?\nmerge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [x] [x] [x] [x] [x] [ ] Concerns: resolved by Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nSlight question about -- normally when dealing with AsRef args, they come in without an explicit reference in the signature (), except when necessary to support a lifetime in the return value (). Currently is declared as: Is this supposed to be instead? concern eqignoreasciicase &amp;S\nI think it should be. I'm not sure why I wrote it like I did originally, but this makes more sense to me. I can make that PR if needed. Or can it be done in the stabilization PR? Not sure what the process is from here.\nresolve eqignoreascii_case &amp;S reviewed Fixed in .\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.\nyou can tick the FCP box, as the FCP is complete."}
{"_id":"doc-en-rust-f8ec7071402e43ae430484c0343bfca03af5fcd3009ca46bcbda1ddb1c535629","title":"","text":"Regression in ( cc modify labels: +regression-from-stable-to-stable -regression-untriaged\nWG-prioritization assigning priority (). label -I-prioritize +P-medium\nBeta backport accepted as per compiler team . A backport PR will be authored by the release team at the end of the current development cycle. label +beta-accepted"}
{"_id":"doc-en-rust-0867c49da7efb293e9753113abb91f30e498ac532bb3b84093850d54c0bc3742","title":"","text":"I tried this code: I expected to see this happen: compilation should fail because the trait impl is defined outside of the module for the type but refers to its private field. Instead, this happened: this compiled successfully This reproduces on the playground for stable Rust, version 1.69.0:\nAdding a main function and attempting to call the (playground link: ) raises the compilation error: !\nThis can be reproduced with cross-crate (e.i., any other crate can access the private field). This means that all encapsulations that take advantage of the field being private can be bypassed. (For example, if we change Vec to a tuple struct, the same thing as setlen could be done in safe code by abusing this bug.) label +I-unsound Also, this can be reproduced in all versions where is stable (e.i., 1.32+). It's a matter of how you initialize Foo. If you provide a constructor for Foo, you won't get a compile error:\nJust for completeness, turning this into a segfault without external crates/just std:\nlabel A-visibility\nthis has been unsound ever since in version 1.32\nWG-prioritization assigning priority (). label -I-prioritize +P-high"}
{"_id":"doc-en-rust-eff82a61886b25b0f1dd4cf2300b1ef5995dc7fc7eccfb7efad8700de136ebcb","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '--edition=2021 --crate-type=lib -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error: prefix is unknown', 'error: internal compiler error: prefix is unknown' File: --snippet: Version information Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: --\n:thinking: this bisects to cc\nvery plausible :+1:\nReduced"}
{"_id":"doc-en-rust-9546ab9a79e7afb097786fe35f6ec641a95b6f3e21077a1cea80490e41620b4f","title":"","text":"The struct is meant to not be constructible. Also the behavior is incoherent between tuple structs (correct behavior) and named structs (incorrect behavior). Also, this is a regression, this didn't use to be the case. No response No response\nlabel +F-never_Type +D-inconsistent\nWe will also get such warnings for private structs with fields of never type (): The struct is never constructed although it is not constructible. This behavior is expected and is not a regression. Did you meet any cases using this way in real world? For the incoherent behavior, we also have: This because we only skip positional ZST (PhantomData and generics), this policy is also applied for never read fields:\nCan you elaborate in which sense it is expected? I can understand that it is expected given the current implementation of Rust. It seems between stable and nightly a new lint was implemented. This lint is expected for inhabited types. However it has false positives on inhabited types, i.e. types that are only meant for type-level usage (for example to implement a trait). I agree we should probably categorize this issue as a false positive of a new lint rather than a regression (technically). Thanks, I can see the idea behind it. I'm not convinced about it though, but it doesn't bother me either. So let's just keep this issue focused on the false positive rather than the inconsistent behavior.\nHow do you think about private structs with fields of never type?\nI would consider it the same as public structs, because they can still be \"constructed\" at the type-level. So they are dynamic dead--code but not dead-code since they are used statically. It would be dead-code though if the type is never used (both in dynamic code and static code, i.e. types).\nActually, thinking about this issue, I don't think this is a false positive only for the never type. I think the whole lint is wrong. The fact that the type is empty is just a proof that constructing it at term-level is not necessary for the type to be \"alive\" (aka usable). This could also be the case with non-empty types. A lot of people just use unit types for type-level usage only (instead of empty types)."}
{"_id":"doc-en-rust-97adf45f9b9e264448b397ec08a8e2a265a07410a46c4023c53938df064ef2be","title":"","text":"So my conclusion would be that linting a type to be dead-code because it is never constructed is brittle as it can't be sure that the type is not meant to be constructed at term-level (and thus only used at type-level). Adding is not a solution because if the type is actually not used at all (including in types) then we actually want the warning. Here is an example: The same thing with a private struct: And now actual dead code:\nI think a better way is: is usually used to do such things like just a proof. Maybe we can add a help for this case.\nBut I agree that we shouldn't emit warnings for pub structs with any fields of never type (and also unit type), this is an intentional behavior.\nOh yes good point. So all good to proceed with adding never type to the list of special types.\nThanks a lot for the quick fix! Once it hits nightly, I'll give it a try. I'm a bit afraid though that this won't fix the underlying problem of understanding which types are not meant to exist at runtime. For example, sometimes instead of using the never type, I also use empty enums such that I can give a name and separate identity to that type. Let's see if it's an issue. If yes, I guess ultimately there would be 2 options: Just use in those cases. Introduce a trait (or better name) for types that are not meant to exist at runtime like unit, never, and phantom types, but could be extended with user types like empty enums. I'll ping this thread again if I actually hit this issue.\nI could test it (using nightly-2024-08-01) and . I just had to change a to in a crate where I didn't have already. Ultimately, is going to be a type alias for so maybe it's not worth supporting it. And thinking about empty enums, this should never be an issue for my particular usage, which is to build empty types. Because either the type takes no parameters in which case I use an empty enum directly. Or it takes parameters and I have to use a struct with fields, and to make the struct empty I also have to add a never field. So my concern in the previous message is not an issue for me."}
{"_id":"doc-en-rust-cc51db125823867db1c0eca8f75c27a06b8dec07dafc7269db7c4a442e8df933","title":"","text":"The PR improved the situation about documenting proc macros. Thanks for that! However, I noticed a bug with it. I'm using . Running results in this: ! Looks like a simple typo or off-by-one or something like that bug. When using only and not s, everything looks good to me. CC\nOh, and also, running prints: Not sure if this warning is expected there. And not sure if related to this bug.\nThis is a consequence of the fact that has not yet been merged. Once it gets merged, and rust updates its Cargo submodule, this issue should go away.\nIt turns out that this issue was unrelated. I've opened a PR to fix it.\nI see. Thanks for your work on this :)"}
{"_id":"doc-en-rust-e21c3ba017dc2f8cb73898979cf59e3a56342a283d84799812dd3475df656304","title":"","text":"This code: produces: Which is invalid. Looks like the span of the desugaring of uses only the part, instead of the span of the entire expression. This results in invalid suggestions when used by the code in .\nI'm not entirely sure if this means that desugaring should use a bigger span, or if the suggestion diagnostic needs to be interpreted differently.\nhmm.. is the only case where the desugared expr's span doesn't cover the whole piece of code it comes from? That doesn't sound right. If wonder if the expr should have the bigger span by default, and then async-specific code could grab the tighter span for diagnostics that need to point at the operator.\nSome of the desugaring only uses the span, but the parts relevant for diagnostics like this do use the full span. Not sure if there's a problem there too.\nI thought I might have accidentally introduced this bug in , but right after that PR was merged, the output was correct: So something changed in the last two months in what spans are used for await desugarings, it seems.\nactually I think it was introduced in in , cc Do you need someone to fix this? I'm happy to put up a quick PR.\nYeah, looks like it: I just finished bisecting, which pointed at a rollup involving .\nthis was introduced in the PR linked earlier to try and improve other errors. It is tricky because reducing the span to only incurs these kind of bugs. On the other hand, the errors that got improved there became much less noisy, so I wouldn't want to revert the whole change. My fix above will solve this issue, but I'm sure there will be others in the future :-/"}
{"_id":"doc-en-rust-bc9cb117386cb67e9ba8fd4c9fe9798fc6eaf751e373139f173791f951053f06","title":"","text":"Follow-up to agreed to move to . Generally I propose that should not contain code that is only needed by CTFE. We have and in there are they need some very deep access to Miri engine internals, but at least those are separate modules. Also, has grown pretty messy, and it does not seem like the order of definitions in that file follows any principle. We could split the file into two similar to what I did with Miri: for implementing the machine trait and defining everything that is needed during CTFE execution, and for defining the setup functions and all the glue that connects CTFE with the rest of the compiler."}
{"_id":"doc-en-rust-d5fac24d636764b5b8baec2c10c5560467a6b65def4df085f9c0e5a36597be4e","title":"","text":"Currently,  is not , since it uses with a non- check: can't be made , since it involves ptr-int cast to check the alignment: Recently intrinsic , it allows to run different code in CTFE and runtime. This, in turn, allows us to only make the alignment check in runtime and ignore it in the CTFE where it doesn't make much sense. See also: cc and (it seems like use of requires approval of all of the above teams) label +T-lang +T-libs +A-const-eval +A-const-fn\nAnother approach to make const would be to disable the checks altogether, but since we already have , that seems unreasonable.\ncc opinions before we escalate to lang and libs?\nIf a new intrinsic was in the spirit of and , this could possibly provide a solution without . Something like:\nIt seems useless to be able to perform any align checks in constants. The CTFE catches invalid pointer dereferences anyways.\nYes, but we also want to catch invalid pointer dereferences when we are not in CTFE, hence the idea of the function/intrinsic.\nSo why not use ?\nIt doesn't catch insufficiently aligned pointers though."}
{"_id":"doc-en-rust-a69881959218c884cf11a0318641ffbb108753fef08afdf8a93ef986bc619e4f","title":"","text":"I'm seeing an internal compiler error on the following input (found by ): My compiler version is: I also observe the error on , but not on ."}
{"_id":"doc-en-rust-49ec9f37f3015e9b3b24c7ec2ddf3b4040d6f440722cb64b31b7c6e3ff8dab25","title":"","text":"I was chatting with today, who mentioned it'd be helpful to mention the newly stabilized APIs from the docs. The benefit of using is that even if the type widens, the result doesn't change. It'd be nice if someone could contribute docs mentioning from . This probably just needs to be a one-liner. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim"}
{"_id":"doc-en-rust-bebf3ac373245cb50b8b4c0e41523bb66c080f59a138926bab54cb74481b9855","title":"","text":"I tried this code: I expected to see this happen: The compilation succeed or guide me to (1) cast the to with . (2) borrow the : . But in this case the addresses printed are the same (what?). Instead, this happened*: Cryptic error message: There is : . It took me minutes before I found the workaround. But it still surprised me. : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nThis creates a reference-to-function-pointer (type ), a double indirection. So it is not what you want. The error could possibly be improved, and the entire situation documented better, but I think getting an error is expected here. is not a function pointer, it is an anonymous ) (of size 0) indicating exactly the function it was created from. This type coerces to a function pointer, but cannot know what type to coerce it to. Printing function pointers is easy (well, if they are not polymorphic via ), but printing these function singleton ZSTs is hard.\nIt might also be worth linting against .\nhelps with the docs. But to close this issue, it would probably make sense to write a lint against where is the name of a function. That should be a matter of adding a new in which checks all expressions for being . That path we can pass to to get a . Now we just need to check if that refers to a function: pass the to . At least I hope that makes sense, someone stop me if this is all wrong. ;)\nI'd like to help write this lint. The default level for the lint should be right? claim\nYeah, feels like a reasonable start.\nNominated for lang team discussion. It seems we usually ask for lints to be approved before shipping them, so let's get that process started. sorry for this, I wasn't aware of this part of the process. You can still go ahead and implement this if you want, but depending on what the lang team decides, we should submit this lint to clippy instead of the compiler itself. That might require minor adjustments, but the main work you are putting in and the testcases will be useful either way."}
{"_id":"doc-en-rust-71ee43a6931324c1d4412d134316ca0db53c2ac8c8b1c9db29569be2e44a0997","title":"","text":":)\nAs a point of interest, this would have been extremely useful in helping debug a segfault in The original code used , not .\nWithout the cast, this should not compile as transmute checks that the sizes match. I assume what you describe happens when using , i.e., not just remove the but also add a .\nUnfortunately I never committed the broken code so I'm not sure what I had originally ... the closest thing is which doesn't compile. Sorry for the noise.\nno worries. I already have the lint implemented, but in that case I'll wait until they discuss to write the tests\nI think should compile. That's no noise, it seems very relevant. :)\npoll T-lang Should we add a lint for taking a reference to a fn?\nTeam member has asked teams: T-lang, for consensus on: [x] [x] [x] [ ] [x] [ ]\nI think I agree here, but to confirm: this isn't actually about linting the taking of a reference to a place of type, but just about using on the voldemort-typed function name constants, right?\nYes.\nDiscussed in a (rather small) meeting today: Those present felt a lint would make sense. If somebody wanted to go ahead and try to author one, please feel free and nominate the resulting PR for discussion.\nall right, so if you want to open a PR, everything is settled for that. :)"}
{"_id":"doc-en-rust-b5cab0ae580415cf68150b68407c363c74d1721e60c8694767e78be194067b97","title":"","text":"Another regresssion of with a different failure path: It should be fixed by ignoring non-captured lifetimes in: cc label regression-from-stable-to-stable C-bug T-compiler T-types A-impl-trait\nNote that fixing this issue is necessary for , but might not be sufficient. I'll investigate more...\nWG-prioritization assigning priority (). label -I-prioritize +P-high"}
{"_id":"doc-en-rust-9870c6488605aefa85aac4fcef8e656ab69c3410ae4e47694e0eba8019bbb511","title":"","text":"Some regressions of that I previously reported in , but they were missed: I guess the way to fix this is to ignore non-captured lifetimes of opaque types here cc label C-bug regression-from-stable-to-stable T-types T-compiler A-impl-trait\nWG-prioritization assigning priority (). label -I-prioritize +P-high"}
{"_id":"doc-en-rust-eaf8aed72a7fb57ad8d28d7447bf226504be02fb120af8e4c8b07e9c7b0dfbfd","title":"","text":"Not sure if we have a test for the following and rust #![feature(markertraitattr)] #[marker] trait Marker {} impl Marker for &' () {} impl Marker for &' () {} If not, we need to add them, since they would be important for special casing during canonicalization. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI can help add this test if needed. (Did not rustbot claim so as to not remove lcnr from assignee)\nSure :) would help out if nothing else\nassign Rageking8\nError: Parsing assign command in failed: ...' Rageking8' ''... Please file an issue on GitHub at if there's a problem with this bot, or reach out on on Zulip.\nassign\nlabel +F-markertraitattr In case this needs to be indexed in the future."}
{"_id":"doc-en-rust-76b755d0637c79bf29192d58b2ad99b90bea0196361a7ec01c503f6ca2dc1e96","title":"","text":"Minimal example: This will complain about multiple mutable borrows, even though it should be valid.\nNoted in (but may deserve a separate bug report?). (FYI, slice patterns are unstable for a reason; they're pretty buggy at the moment).\nshould be closed after MIR borrowck will be by default"}
{"_id":"doc-en-rust-f461ed06d710504006ceae7c5fcd57c22a21594ee3506845299df89352356a02","title":"","text":"I tried this code: with and . I expected to see this happen: No internal fields of the should be displayed as users won't be able to use the fields, making their appearance confusing and useless. Instead, this happened: The internal fields of the are displayed ! Real impact as can be seen . : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nlabels +T-rustdoc +A-rustdoc-ui -needs-triage claim\nDupe of and more discussion there"}
{"_id":"doc-en-rust-fd045c825f7948ab3b986a03fca4367a41295e54eac04fecbbe5ced0ae0e71ff","title":"","text":"Using to document private types of the current workspace exposes external types private implementation details (in this case private fields). I would expect the expansion to limit itself to public fields. e.g. gives ! <details<summary<coderustc --version --verbose</code</summary<p</p</detailsr?\nI suppose it's \"ok\" since you used the option. I'll add it to the next rustdoc team meeting agenda to be confirmed by the team.\nRendered output for anyone wondering: !\nI'll summarize the exchange I had with Guillaume on matrix. First, the flag I'm talking about is the one you provide to . does not blindly pass the flag to but only for crates you own in your current workspace. That means that when documenting your workspace with . Private items, fields of your crates are shown contrary to your dependencies. Regarding design, it seems weird to me that aliased type expansion shows private implementation details of dependencies (e.g. for the given example). I would personally expect something like:"}
{"_id":"doc-en-rust-bad15165f9c17e24bf9acf94720de1600514f6cf5915295f602149400d545451","title":"","text":"Binder(<[type error] as ToBytes) This only happens if there are two erroneous functions, if I take out it works fine. It seems like I was trying to do this wrong in the first place since the first function gives an error . Not sure what the right way to do this is. <details<summaryTraceback</summary</details\nTried to reduce it and found a similar case with the same ICE:\nCompiler triage: Seems likely to be caused by the need for lazy norm. Marking as p-medium for now.\nThe ICE doesn't appear on the latest nightly, marked as E-needstest"}
{"_id":"doc-en-rust-9f7caf72595177bf2822e32eb545f7227354c9856f07d783118015d474032cf3","title":"","text":"contains a function, which allows to to, well, retokenize existing span: There's only caller of this function: And there's only one caller of that caller: In other words, the only reason why we need is to get the span of hir::Usewhich happens to be a glob import. ( rls needs to know the span of use foo:: with explicit list of imported items\" code action. This was the first demoed code action and is still that is implemented ) I'd like to remove the function, as it is one of the few remaining things that requires to be public, and as it is very much a hack anyway. Additionally, I believe I've broken this function accidently a while ago: Rather than retokenizing a span, it retokenized file from the begining until the end of the span (whcih, as uses are usually on top, worked correctly most of the times by accident). What would be the best way to fix this? Add hir::Use-- this seem to be the \"proper\" solution here Move hack's implementation to where it belongs: in , just fetch the text of the file and look for ('') Remove the deglog functionlity from RLS? I don't like this option as it handicaps the RLS before we formally decided to deprecated it. But I don't completely disregard it either, as, as a whole, it seems to be a full-stack one off hack penetrating every layer of abstraction. WDYT?\nI'd suggest the second alternative (move hack's implementation to in librutcsaveanalysis), save analysis is a home of many hacks already and one more until save analysis is deprecated in its entirety won't hurt. Adding span for would be ok if it were useful for anything else at least."}
{"_id":"doc-en-rust-a79726a7a5bc3584f3098659f7e4fa406d31855e67561797cc71bb1ce369ebc6","title":"","text":"proc-macro derive panicked All of the 62 regressions are due to old versions of having an assert expecting instead of . So this is again a consequence of whitespace changes in pretty-printing (). I think we should be able to fix this by special casing the comma token during token stream pretty-printing and not printing the space before it.\nFixed in\nJust FYI, we discussed this in the meeting. We felt like the action here was appropriate -- while in general we do not guarantee stability of pretty printing, it makes sense to be judicious, and in this particular case not having a leading space before just looks better anyway."}
{"_id":"doc-en-rust-7de2dab580f301c8ce6b2809875c28dcb5912dccad192bd07b5e03d66bc6bf9a","title":"","text":"() Reproduces on the playground using . label +D-incorrect +F-gen_blocks +requires-nightly"}
{"_id":"doc-en-rust-d9fb93fd47178194cddc44ad9d417e244eb5a904acffc59ea7424cd56145c38b","title":"","text":"Currently we do ensure on CI that works, but doctests are enabled as I couldn't figure out how to get this to work within bootstrap. However, that has let slip through. So ideally we can figure out these bootstrap issues and test rustdoc inside on rustc CI.\nHere's what currently happens: shows a similar error. So... probably we're using the wrong rustdoc? I assume it's the bootstrap rustdoc, if that's a thing? I can't even see a rustdoc being built in the build log. We want the rustdoc that is produced by stage 0 here, since we are testing the Miri produced by stage 0. How do we get that? Cc\nlooks to be the reason we're running a random rustdoc here. I suspect we'll need to thread through a custom bootstrap env variable, since IIRC there's no RUSTDOC_WRAPPER that miri can use to thread state. Alternatively it might work to adjust miri such that it remembers which toolchain is running earlier, but I suspect that'll be harder. As-is though it's almost certainly semi-broken for any Rust user doing something like presumably, where their default toolchain isn't nightly?\nIt seems to be working, AFAIK rustup ensures that nested calls use the -specified toolchain. Or maybe we are just lucky... But yes we should in the outermost wrapper, determine which rustdoc cargo would invoke using the same logic as cargo store that in a miri-private env var invoke that in I assume however we'll also need further changes in how bootstrap invokes cargo-miri to tell it where the right rustdoc lives? Currently we're not even building rustdoc so something surely needs to change in bootstrap. I see this snippet a few times, is that all we need?\nYeah, I'd expect that to be enough to start with at least. Also potentially relevant: If we're already using somewhere in there (we should be, probably?) then that should already get mostly setup, see here: ,\nWe do that already: Unless you are trying stage 0, you should be able to see rustdoc compilation in the build logs.\nThis is stage 0. It should still have to build rustdoc, stage 0 Miri needs stage 0 rustdoc (not bootstrap rustdoc) for its doctests."}
{"_id":"doc-en-rust-9d0d7eeda2b69e94e7cde3dfe2acdbf0ee78c259476be49d191408e1d23792ce","title":"","text":"(...) ah fun, so if we invoke RUSTDOC we'll actually invoke bootstrap's rustdoc wrapper. We'll have to see if having both Miri and that wrapper around will work.^^\nNever mind, that was for a build. For stage 0 this doesn't happen. I don't think this can work though... The staging with Miri is a bit weird; we need a stage 1 std as well for our stage 0 tests. Specifically we need a host sysroot that was built with a compiler that \"is the same as\" Miri, i.e. that is fully compatible. (The is wrong, it's not the compiler that built Miri.) This was needed to make build scripts and proc macros work in .\nYes, and if you want to use the actual rustdoc without wrapper, you can invoke . I tried using env instead of plain \"rustdoc\" and this is the output:\nI had to manually pass from the cargo miri test caller; it turns out we are not passing it by default (or it somehow gets removed later?). Anyway, this is how I tested it:\nYeah currently this does not work due to But you have already come closer than I did. :) Was that with or stage 1? Maybe is ?\nI guess that needs to be resolved first before we enable doctests on cargo miri test ? It was stage 1. Yeah, it seems like.\nYes. must continue working. I don't want to always build rustc twice when working on Miri in the tree.^^ But if necessary we could enable doc-tests only for higher stages... that would still be better than the status quo."}
{"_id":"doc-en-rust-14d87f94d6dd2f60938cc3099809c6fbd53892083d65f782d3f0ae98e232297d","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\n`\nlabel +S-bug-has-mcve\nWhat is the expected output here? Can this actually compile, and if so, what does refer to?"}
{"_id":"doc-en-rust-406a2986ff0ccb500658ee5abeb43b92da770a2e1e06ad8161c217272f3e9cc5","title":"","text":"I tried this code (): I expected to see this happen: rustc outputs an error saying that I need to add the and traits on . Instead, this happened: which is jarring to see, and unhelpful, because HashMap does support Index, but only with particular trait bounds on . <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nThe reduced case: works as expected, perhaps it is caused when the implementer is not from the local crate?\nclaim"}
{"_id":"doc-en-rust-05a1381dc80d91495ba832a3bb44413d26c97c0b2f6bdb516422ccddc1ddfe33","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 . The feature adds the method to , which allow a safe transformation from a to a . [x] [x] [ ] None yet.\nIt's from a , right? The nesting is a bit odd. But I guess it is what comes up in practice?\nAh, yes, sorry — fixed!\nAre there any remaining blockers on this? It's a pretty useful function for blanket impls for traits with poll methods (e.g. Future already uses it in its impl).\nNot that I know of — given it touches the machinery, I suspect it should go through an actual FCP, but I'll let others be the judge of that :)\nCurrently this method is located in its own solitary impl block: I'd like to consider changing it to: Some advantages: Synergy with the existing and signatures (stable since Rust 1.33) Lifetime elision reduces noise in the signature Turbofish less verbose: vs\nAny concern blocks this from stablization?\nI agree — that is better :+1:\nWould it be possible to start an FCP on this?\nfcp merge  is like , but without enforcing an unnecessary . It is like , but is unconditionally safe. The use case arises in real-world code when you are implementing a trait that takes where the Self type of your impl is . So what you have is something like , and want to delegate to the impl for which takes . Some examples: In tokio:  In hyper:  In futures:  In actix:  In libcore:\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."}
{"_id":"doc-en-rust-2b12794ca3af624f916356e29cd2b0bee18cadf584215dbc6944cd8163126a45","title":"","text":"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-64b23c5c36e9988ec4c5b0f9b27af4a414e6c71c77fec9aaba09da710256fe45","title":"","text":"I wrote code that looked like this while not having my brain turned on 100%. Due to said brain not functioning, it took me a while to understand what rustc was trying to tell me with the message pointing to the pattern with the text . sure looked like a unit variant to me! What rustc was trying to tell me was that the definition of the variant was a struct variant (\"found struct variant\") and my pattern wasn't matching the definition (\"this pattern you specified looks like it's trying to match a variant that is not a unit struct, unit variant or constant\"). The change I needed to make was adding to my pattern, because I was trying to distinguish different variants from each other, not use pieces within the variants. Suggesting seems like a decent starting point to me, but there could definitely be cases I'm not considering here and I'm totally open to hearing that No response No response <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nWEIRD this PR looks like it implements what I wish rustc did: but the test files in that PR say they're for and I'm getting\nAha ok this test shows that for tuple variants, rustc will suggest adding : and that test also shows that rustc isn't suggesting anything for struct variants!\nAha and it looks like adding struct fields was more complex so that's why it wasn't done?\nclaim"}
{"_id":"doc-en-rust-1e4df30a7ceba21852c6ed075eb049ae6714282c369dffcdc43b0f08eb472d35","title":"","text":"Not sure how helpful those notes are but I put them in here. Working on a web application using Sycamore.\nWhat's the code that induced this compiler panic?\nlabel +E-needs-mcve\nThis happened to me with . Removing a whitespace at the end of a line made the compiler panic. I attach a minimized workspace to reproduce the crash. What's funny is that there is a file () where deleting even just one character makes the crash disappear.\nGiven that this automated(?) reduction is still a big workspace, I'm actually going to leave the here because my hunch is this is still probably further minimizable, but thank you! Entirely possible I'm wrong, and this should be reduced enough to go by.\nA slightly smaller ICE reproducer:\nIt appears the content after the function name and parameters , starting after the return , ending at the function body's enclosing brace, will trigger the ICE. If I change the lifetime name to shorter than 3 characters, it does not ICE, e.g. doesn't ice, but will.\nI think I found the issue: it has to do with interning. Specifically, if you manage to fit a function of the following signature to somewhere around (defined in ) it will trigger some kind of edge case in span data interning and cause the to be confused with (or for some other cause that lead to this). Minimal reproducer is just and longer lifetime names will also trigger ICE.\nCan someone else try to see if this ICEs for them? I can reproduce the ICE on nightly but stable seems to handle it just fine.\nsearched nightlies: from nightly-2022-01-01 to nightly-2023-02-10 regressed nightly: nightly-2023-01-03 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\nThe bug is that . The \"inline format with parent\" should check than ."}
{"_id":"doc-en-rust-68be5724b3b1ef2d5077bd80f85030139d8aa3b845ccb821ef16c47a34f61577","title":"","text":"The feature allows calling any expression of a tuple-like constructor in a : cc\nImplemented on 2019-06-07 by in which was reviewed by\nIs there anything else needs to be done to resolve this issue?\nFCP and stabilization pull request.\nDo you think you have time to write a report (e.g. in the style of ) and amend the reference after?\nI propose that we stabilize . Tracking issue: Version target: 1.40 (2019-11-05 =beta, 2019-12-19 =stable). Tuple struct and tuple variant constructors are now considered to be constant functions. As such a call expression where the callee has a tuple struct or variant constructor \"function item\" type can be called : Consistency with other . This should also ensure that constructors implement traits and can be coerced to function pointers, if they are introduced. - Tests various syntactic forms, use in both and items, and constructors in both the current and extern crates. The case in should also get a test.\nThanks! Could you embed this report in a PR with the aforementioned test there as well? I'll FCP that PR."}
{"_id":"doc-en-rust-dda53e6e6669bb67565cbda4f5249392dec83d9adef3173487f24b0d81452468","title":"","text":"When using to create an enum variant in Rust 1.37+, we get an error: results in: but if the enum is constructed explicitly, the compilation succeeds: Looking at , it looks like should be considered a with . Playground links for both variants: ,\nDuplicate of (will close in a bit). It seems like folks open this issue because on stable, the error message does not point to the tracking issue, e.g. you don't see: can we fix this?\nI think we should just stabilize it\nIs this diagnostics problem specific to this feature gate? I meant a more general fix to const-fn related gates.\nNot sure. I thought we're using the normal feature gate infra\nReopening this to make sure we add a test per"}
{"_id":"doc-en-rust-8b0125de1cc299f933fe5b7f70dd3f5512334973a1d755f2064b11b62d253f83","title":"","text":"As it is currently written, E0207 talks entirely about type parameters. Now that const parameters also need to constrain implementations (under the same rules described for types), they also need to be mentioned in the error explanation. Since other items don't require const parameters to be used at all, we might also want to specifically call out this difference here. Furthermore, E0207 triggers if you use an unconstrained lifetime in an associated type, and this is completely unspecified by the error as well. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim"}
{"_id":"doc-en-rust-8aab2eabc1565327b3acc84c5358e9c71ba3303e9f7d58582dfb5d458f7a557d","title":"","text":"<!-- ICE: Rustc '' 'thread 'rustc' panicked at 'called on a value'', 'thread 'rustc' panicked at 'called on a value'' 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: [mirborrowck] borrow-checking [mirdropselaboratedandconstchecked] elaborating drops for [mirforctfe] caching mir of for CTFE [evaltoallocationraw] const-evaluating + checking [evaltovaltree] evaluating type-level constant [checkwellformed] checking that is well-formed [checkmodtypewf] checking that types are well-formed in top-level module [analysis] running analysis passes on this crate --\nRegression in nightly-2022-06-08 found 7 bors merge commits in the specified range commit[0] 2022-06-06: Auto merge of - flip1995:clippyup, r=Manishearth commit[1] 2022-06-06: Auto merge of - matthiaskrgr:rollup-ajyvjd3, r=matthiaskrgr commit[2] 2022-06-07: Auto merge of - RalfJung:miri, r=RalfJung commit[3] 2022-06-07: Auto merge of - jackh726:remove-borrowck-mode, r=nikomatsakis commit[4] 2022-06-07: Auto merge of - scottmcm:add-coldcc, r=nagisa,lcnr commit[5] 2022-06-07: Auto merge of - Dylan-DPC:rollup-ya51k1k, r=Dylan-DPC commit[6] 2022-06-07: Auto merge of - Dylan-DPC:rollup-0ae3pwp, r=Dylan-DPC ERROR: no CI builds available between and within last 167 days\nI guess? :thinking:"}
{"_id":"doc-en-rust-74b899210eaa21303569f49e98f3a4ec464f8de75bd92f6a0a377dd2666b87a4","title":"","text":"E.g. in we had to use weird code to check that the iterator is the same length as a slice. After changing the function to have an ExactSizeIterator bound, we should undo the hack <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nWhat do you mean by \"many\"? Is this about grepping returns in and replacing them with whenever possible? I'd like to give this a try but not sure what exactly this is asking.\nAh, not libstd, just in the compiler. But yea, you got the right idea, grep for it, see if it can be ExactSizeIterator, if not leave it\nHi, this looks pretty easy and I would actually try to get involved into rustc - could I take this one as starting point for incoming weekend?\nGo for it. Just search for returns in the compiler source code and replace them with whenever possible.\nclaim"}
{"_id":"doc-en-rust-149edd16fbcc394a726cd24ee1d332167d49d0f05cfb412bdbe8f4fe87708b2a","title":"","text":"When I install the latest master toolchains via and try to build with them, linking fails: I did some bisection, and it looks like the problem started happening with Cc\nThe error is actually already mentioned in However, I am building Miri with cargo, so I don't know how I'd \"use LLD instead\".\nHm, we probably need to revert that PR. I did not realize we'd need lld downstream too, I thought that was only on our builder. cc\nYes, a revert seems appropriate. We're going to have to figure out where that's actually coming from. The only change I saw between 10 and 11 by grepping was the removal of llgo, but maybe there's some bad remnant.\nYeah, I thought this issue would be limited to the rustc build, but it makes sense that it can also affect project linking against rustc shared objects. I've looked a bit into what the root cause is, and what I have so far as that the symbol comes from and is present as a weak symbol both when compiling with clang-10 and clang-11. The only difference I see from is this: So apparently was treated as a symbol of the library, while now it's treated as a symbol of -- I'm not sure what that actually means, but presumably that refers to the compiler runtime libraries. My guess is that previously it just ended up being nulled out as a missing weak symbol, but now it's actually being found and linking fails because ... reasons. I'm not good at linkers :) Edit: shows these as:\ncan you prepare a revert PR?\nDone in . If nobody has an idea on how to avoid the linker error, two more options would be to comment out the symbol in our llvm-project fork, or to avoid upgrading clang altogether and just build both Python 2 and Python 3 for that image.\nThe issue is probably going to be in how exactly the objects that comprise are compiled, not linked. I suspect just ends up ignoring the malformed object or otherwise not reporting the issue, but the object and the relevant symbols ultimately end up in the anyway. Alas, reasons these obscure failures can occur are many – I've seen them occur from things as trivial as forgetting to . The question is: is there perhaps a way to disable ExecutionEngine entirely? Intuitively nothing we do should depend on that code."}
{"_id":"doc-en-rust-4ff3af9619d28dadd6dc9c4368ec6277d3cf2c1ae698d090dad0b152ac47f3b3","title":"","text":"And if not, I'm comfortable patching out in our fork as we get closer to Feb 11 and continue having trouble pinpointing exact cause of this problem.\nWe normally don't link ExecutionEngine, but dist-x8664-linux in particular builds LLVM with ThinLTO, in which case we link as shared, instead of statically linking individual components into rustcllvm.\nIt seems to be possible to configure the components in using , but I'm not sure to what degree we can restrict those (not sure if this job also ships LLVM tools).\nSo, I think we could have used to exclude unnecessary parts from , as LLVM tools can still statically link the parts not in the dylib. But in the end, we can't use the option anyway due to\nLooks like I'm getting this locally when trying to bootstrap rustc (while building ), might happen since the llvm upgrade but I'm not 100% sure. Are there some workarounds I can put into my for this? I'm using lld to link. <details<summaryBacktrace</summary<p</p</details\nwhich commit are you trying to build?\nlatest git master\nProbably best to open a new issue then; this one has been closed and the steps to reproduce it still work without error -- you might be having a different problem.\nOpened\nDid anyone file an upstream bug report about this? I'm observing it outside of Rust, but with a similar setup ( with lld+ThinLTO, then linking it into a binary with ). If not, I'd try to build a reproducer.\nI've opened for this.\nThe bug has been fixed, the fix will be in LLVM 12.0.1.\nThanks! We can try updating clang again once the 12.0.1 tag is there."}
{"_id":"doc-en-rust-9a95006cdee7ec6d714899fa0063d6fdc5a7214362293f889c5299ef9982da48","title":"","text":"I'm having trouble linking a Rust program to a non-position-independent C library. When I manually remove the flag from the ld step that rustc runs, everything works correctly. I think that should remove the flag for me, but it doesn't. Here's what I think is going on: When I run It runs ld with the flag: But when I read the rustc code , it seems like the intention is that should only be passed to ld when . That is, if we're not compiling a position independent executable, then we should not pass the position independent executable flag to ld. I think what may be happening here is that somehow the defaults from are overriding the command line options I'm setting. This happens with stable and also the nightly I tried:\nand are two distinct things. is also unrelated to the option. Interestingly, I do not remember us having an option to disable PIE; we should have one.\nI did a bit of reading and here's what I figured out, please correct me if any of this is wrong. Linkers are new to me! Rust builds position independent executables by default on platforms that support it. These platforms have a relocation model of pic in their target config. The is what sets that linker option, except if it's disallowed by . The correct solution to this is to add a codegen flag, or something like that. Does this sound right?\nHi, I am having the same issue. I am trying to link against non-position-independent C library, build process ends without error but results returned by Rust bindings are different (and incorrect) than those returned from clean C implementation. In order to overcome that issue currently I am setting RUSTFLAGS=\"-C relocation-model=dynamic-no-pic -C linker=./linker\" where linker is bash script that wraps cc and filter -pie flags:\nI'm also having this problem. I assumed that passing when doing a build would suppress on the linker command line. (cc:\nI'm still seeing this issue. Not sure if it's a regression or I'm doing something wrong. I have a \"hello world\" program in , and when I run , the resulting call to includes . I'm using nightly rust on Ubuntu: .\nSo, the problem here isn't with rust, but with the linker."}
{"_id":"doc-en-rust-2c4b59438aae4a98738c310a7146d165f59e40551664b4a22c1f0717772e355f","title":"","text":"In Ubuntu 15.10 and later the default GCC toolchain installed has been compiled with which causes and to be passed to during code generation and to during linking. Now, the linking part is what is important here as rust on most platforms uses as the linker for most targets. So, though no PIC or PIE code may have been generated by , the linker will still try to link as with PIE in mind, breaking when trying to compile with and the like. To work around this will need to see that the linker has been compiled with PIE as the default and pass to the linker if using GCC or something similar for other linkers. Code to do this can be seen in for Tarpaulin though it is only meant for Linux in that state and can be improved greatly if in tree. EDIT: Don't know why Github isn't linking cross-project PRs correctly right now.\nCan this issue be resolved by always passing , except when compiling with ?\nSadly, no. In testing I have seen that any build of GCC that was not built with rejects the option and fails to run. This is why in the PR that I linked the linker was queried to see if it was compiled with before tacking on .\nSo it's came out from the discussion on an issue related to this in tarpaulin that passing -no-pie before -shared (and maybe then -static if it exists for static linkages as well) resolves the issue. I'm going to test this tarpaulin side and I can report back but I feel it would be best if this could be solved rustc side as it can affect any user in a similar situation."}
{"_id":"doc-en-rust-2104c8e6bf9e2797bcd7cd1ab7750453fb0d900ab6484d0cbeb94c35ea8004f6","title":"","text":"gives a warning, but does not.\nsuggested that we test this out with crater to see if this would generate much substantial noise and how common it would be.\nI'd expect it'd be a pretty substantial source of warnings, but that's exactly why I think we should introduce it. People compiling with are asking for these sorts of bugs to be caught, and we should serve them appropriately ;) In any case, running crater would require having an implementation to do a crater run on, so let's do it!\nLet's do it. (I'd personally even like an attribute to allow people to opt-in to this for , for example, when T is itself . That way if I make a , I'll get a warning on that I normally wouldn't want but plausibly do now that I'm getting s in the s.)\nI've opened a pull request to try this out:\nWe discussed this on the language team meeting; folks felt generally positive, but we'd like to do a crater run to see what the impact would be like and if there would be many false positives.\nI tried this using but it does not seemed to complain when the part of is not used, is the the correct behavior? I hit this when doing where I didn't use part of the tuple which cause it to not work, which I did not know is required to be used.\nputting it into a binding, even an unused one, is considered a use, like how doesn't lint. With just calling it lints:"}
{"_id":"doc-en-rust-720a5af7afe29e212deb5bca365c920ea90a61e0ab1beeab54ba376512407424","title":"","text":"<!-- While learning rust from the book i tried printing the second(.1) value in a tuple, and it broke the format string and wouldn't compile --I tried this code: I expected to see this happen: printing of the value 1. Instead, this happened: it gave the following error: if you intended to print , you can escape it using rustc <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nOnly printing an identifer is supported, arbitrary expressions are not: https://rust-\nThere's more discussion about this in or in many other places, it's a thing that keeps coming up.\nThe error message could be nicer, so I'll convert it into a diagnostics issue."}
{"_id":"doc-en-rust-9311e346092682e2a666e259f32edcd584afc27817add1dd6ceddc3df74d3576","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\nIt looks like it's correctly complied on rustc 1.48.0-nightly:\nI dont think this should compile at all. After all, we cause UB, the value of the const generic does not comply with the rules of .\nA str being valid utf-8 is not a language invariant, so this should not be UB to my knowledge. cc I do expect this to be the correct behavior, so marking as\nWe do have to compare the s to check for equality though, which might cause library ub so :shrug:\nI think you are free to decide on your own invariant here -- assuming that two are equal if and only if the underlying are equal, it's your call whether you want to allow non-UTF-8 in types or not. What is the plan for other library types? Like, imagine a user defined a newtype around that must be even. The compiler cannot even know that such an invariant exists so it cannot be enforced. Equality checking anyway happens by comparing the underlying bytes. So if we follow that analogy, the non-UTF-8 should be fine, but we have to make sure that we use the right notion of equality.\n:+1: yeah, see for more details here I guess One concern is that we probably want to print s in and in encodings, so we need to either deal with invalid utf there or forbid it entirely :thinking: Will have to keep that in mind before stabilizing parameters.\nYeah, you could either use (so any special treatment of is confined to the printing code) or make a very special compiler-understood type even for the type system itself (and reject non-UTF-8 strings early). The former seems more principled to me but that is just a slight preference."}
{"_id":"doc-en-rust-daf8e17864d8f503a9064f06a1f811a9aa1e58a1541c3681f8540ef134806127","title":"","text":"won't work for symbol mangling, as otherwise two distinct types can have the same symbol: (current ICE is unrelated, as const generics is not yet fully supported there) Printing invalid utf8 as bytes might be simpler there :thinking: I guess cc about that\nOh, this is not just pretty-printing but needs to be injective? Then I guess some or so (for \"invalid\") would work."}
{"_id":"doc-en-rust-ca024e14f49f0dd23c01f572db476d23c938022645617c1074021fced75ee0f8","title":"","text":"If you , you get a normal error like but if you try to at the same time: rust will panic which is a bit weird. Mayne that panic should be demoted to a regular error? <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nTo reproduce: `\nclaim"}
{"_id":"doc-en-rust-513b6b205a8e86c25337104c413583c58d5aece913de7870c40f446389b20b96","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 making the function . <!-- 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.\nThis got reverted again by , but hopefully we can re-land it soon.\nSorry, I misread, this feature gate is not affected (but some others are).\nAny news on this?"}
{"_id":"doc-en-rust-943c5e4a48d1b46c8b88f3d683338cde402dbd95a6df5492bc9d381f1be16e15","title":"","text":"I don't see anything holding it back; especially now that transmute itself is const. EDIT: Never mind, I just saw\nSince is const-stable nowadays, I think this can be stabilized as well. Feel free to open a PR. :) Cc\nI didn't do this before, I am reading the docs for how to do this, and there's an rfcbot final commenting period thing. Should this be done? If yes, how? I probably don't have the rights to do it.\nYou just need to prepare a PR. I can help get the FCP process started in the PR."}
{"_id":"doc-en-rust-99c889b6440041652c587ab3ef8b73797f12c011e66f29f49153e5655b8da3be","title":"","text":"I'm pretty sure it is possible to set custom paths for , & in but not for clippy.\nlabel +T-bootstrap"}
{"_id":"doc-en-rust-a48b7de958c52aaf8f6556c4a1124cd11db50916d01764712aa5be78a9e191d2","title":"","text":"and I are working on diagnostics for the rest idiom in slice patterns () and came across this issue when an attempt is made to use it in tuples and tuple structs. IIUC, this is allowed: and this is not allowed (note the addition of ): The error messages for the tuple and tuple struct cases include the following incorrect information: This should state that the id binding to rest is not allowed. patterns are allowed. is only allowed in slice patterns, not in tuple or tuple struct patterns. This should state that the idiom is only allowed in slice patterns. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nappears to be the site of the check: This method is called:\nPerhaps it's worth supporting \"tuple slicing\" pattern too in Rust:\nthat would implicitly create a tuple for (or a slice?). I don't think it'd be a good addition. We already support , which is much more useful in my eyes.\nThat syntax is meant to produce a shorter tuple xs with the omission of the first item of the tuple. lf you think it's an useless idea then let's ignore it :)\nclaim"}
{"_id":"doc-en-rust-a5d530450e0e50c2933792074791027b8b55354140db2b87b4f01f2a5604a335","title":"","text":"Currently, will panic, but will not, because the expression is not evaluated in that case.\nAlso, crashes the compiler. Maybe it's the same issue?\nThanks for the reminder, fixes that as well."}
{"_id":"doc-en-rust-73377bad6f7b525ef11be4069ed1c051993a4f14fef5e78d00d8df7bd15081c1","title":"","text":"Mm, we have \"method macros\" but now there are other things that can go in a trait.\nSeems to be fixed by , but I don't see tests for it specifically, so I guess this needs tests."}
{"_id":"doc-en-rust-3f60b45e20af95737c9e0214e9f8f0071ba2ee95a83ead9cff219248fceb9de9","title":"","text":"Rust Version: rustc 1.0.0-nightly ( 2015-02-12 00:38:24 +0000) Description: When compiling the following code with rustc the output is: ERROR:rbml::reader: failed to find block with tag 7 error: internal compiler error: unexpected panic note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: run with for a backtrace thread 'rustc' panicked at 'explicit panic', C:botslavenightly-dist-rustc-win-64buildsrclibrbml stack backtrace: 1: 0x69bfbbeb - sys::backtrace::write::h57b621d79849130fitB 2: 0x69c13974 - rt::unwind::register::h686925f8fa692ab9GSJ 3: 0x69b836ef - rt::unwind::beginunwindinner::hc2a974b1bdaa4639YPJ 4: 0x302da8 - reader::maybegetdoc::h2547f886a15a227erHa 5: 0x301d2f - reader::getdoc::hc198b8918d0de179nLa 6: 0x1138635 - metadata::decoder::itemtype::h7f6e008c4a79af18mck 7: 0x11480d9 - metadata::decoder::gettype::h9620389d7a7d23c0Xok 8: 0x10fb7a8 - metadata::csearch::gettype::h3af5a6a2534b2d8bCkn 9: 0x6d605059 - collect::CollectCtxt<'a, 'tcx.AstConv<'tcx::getitemtypescheme::he174d5be00f2627cMFw 10: 0x6d5f49ab - rscope::ShiftedRscope<'r.RegionScope::anonregions::h0a5ed4a2d46d3aeeqlu 11: 0x6d5f64ef - rscope::ShiftedRscope<'r."}
{"_id":"doc-en-rust-e22997e749fec142525ff01109d9cba3949e321f7766c70e2b76034ebf7cb232","title":"","text":"RegionScope::anonregions::h0a5ed4a2d46d3aeeqlu 12: 0x6d5978bd - astconv::asttytoty::h1dadfccc9ddb5e90VHv 13: 0x6d5ef523 - rscope::ShiftedRscope<'r.RegionScope::anonregions::h0a5ed4a2d46d3aeeqlu 14: 0x6d5fa734 - rscope::ShiftedRscope<'r.RegionScope::anonregions::h0a5ed4a2d46d3aeeqlu 15: 0x6d61330f - collect::CollectCtxt<'a, 'tcx.AstConv<'tcx::tcx::hf449f596d422460aAFw 16: 0x6d60a79a - collect::CollectCtxt<'a, 'tcx."}
{"_id":"doc-en-rust-bf010bbe00291fcfccd5d40fc05f3efe54f0baf3ceac28cd896abfd023b4d4ab","title":"","text":"AstConv<'tcx::getitemtypescheme::he174d5be00f2627cMFw 17: 0x6d643867 - checkcrate::h72731a5b4298723fkrB 18: 0x6d64131c - checkcrate::h72731a5b4298723fkrB 19: 0x70b1eb58 - driver::phase3runanalysispasses::hc863f28a1bd50b11SGa 20: 0x70b02618 - driver::compileinput::hd580d8c011d24ba3Eba 21: 0x70bcfc4c - runcompiler::hb48a33a057cced0e5bc 22: 0x70bcd85b - run::h3df2025cf41d43b3Ibc 23: 0x70bcc56a - run::h3df2025cf41d43b3Ibc 24: 0x69c4180c - rusttry 25: 0x69c417e9 - rusttry 26: 0x70bccbdc - run::h3df2025cf41d43b3Ibc 27: 0x69c03ae2 - sys::tcp::TcpListener::bind::h2319ec78a0f49dc2faF 28: 0x770f59ed - BaseThreadInitThunk\nSame error as ."}
{"_id":"doc-en-rust-a8def8af1fcc71783452b7cda89d38003e28dea8253e1129cbd63f10824dfc7a","title":"","text":"I got this while trying to implement something similar to a FromStr trait and tried to rely on a lot of inferencing when calling it. I can try to extract a standalone example if needed.\nThis ICE is also producible by trying to refer to an associated type that's never defined. is accepted by the compiler when it clearly should not be - what on earth is ? The following and code cases the same ICE. Here's the stack trace:"}
{"_id":"doc-en-rust-1cc90389fadf9f8609d715499f2e82e189b8fa02b4d3f7cb662f32cd4315de73","title":"","text":"I get the ICE below when I compile this fragment of code: The above structs are defined here: The above fragment is part of That crate depends on And that crate requires erlang-17.4 to be installed.\nA minimal program to demonstrate the crash is..."}
{"_id":"doc-en-rust-ff1eabcc4d6c5e3872309db30a1fac2ba80cabfd742201548cc727e2fed412d4","title":"","text":"compile with opt-level = 2 (works fine with opt-level=0)\nstrange. the program looks legit to me.\nthis works for me now, as of\nThis prints on all opt levels for me at ."}
{"_id":"doc-en-rust-09dba29fa8aa11509d6cd49c561b11d2548cab6627b306896c4b759f3fbc1ad4","title":"","text":"I tried compiling this code: which resulted in the following output of rustc: So the compiler says So I tried adding a borrow and recompiling the code: which resulted in: so the compiler says and so I'm stuck in a loop. The compiler can't decide whether I should borrow or not. As a newbie to Rust, this is very frustrating and the opposite of helpful, it just confuses me further. Please fix this indecisiveness :) :\nFor reference, what you likely want to do is one of the following which means they cannot be the type of a local binding. You can give a binding a slice type (), because that's morally equivalent to a pointer (with sizing info), which has a compile time determined size, as all borrows are .\nCurrent output: After :"}
{"_id":"doc-en-rust-ac0d9f4d8358a27aaa8edf3b10efc5a466a061e285df23b4965a04f245cadeb1","title":"","text":"Implemented in rust impl<T: PartialEqVec<T{ pub fn remove_item(&mut self, item: &T) -Option<T{ /…/ } }\nPR moved to due to reasons\nComments from original thread: think that we should add this method to too. desired?\nfor you can simply do\nI meant specifically a method that searches for the item from the end of the vec instead of the beginning\nWhat do you think about adding ? Just as reduces the runtime complexity from O(n) to O(1) compared to , would reduce it from O(n + (n-m)) to O(n).\nI like .\nIt would be nice if this was more generic. let v: Vec<String= Vec::new(); v.removeitem(\"s\"); <-- fails because &str is not a &String we really want the removeitem \"item: &T\" to be \"something that we can compare equality with the type in the container\". This would let remove_item() walk the T items, compare equality, and remove if equal.\nSeems reasonable to change the signature to\nReviewing the naming used in method names and the docs, it would seem that iterators yield items while vecs contain elements. Considering that we then we should also remove elements and the method should be called . That name is a bit long so I'd propose simply . However I wonder if we should favor a more general , or have both.\nAny plan to stabilize this?\nThis has been in nightly for a year with no issue reported on the method itself. There are proposals for additional methods, but that shouldn’t block this one. Please submit separate PRs or RFCs. 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] [x] Concerns: resolved by 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.\nAre we switching to a bound?\nOops, sorry I missed that. Yes, let’s."}
{"_id":"doc-en-rust-ee2c3a2cd4dd5f9723f8f1799ba3cb7cbe231b418343002b2cab203d04069198","title":"","text":"Again here, as a maintainer of collections that offer the Vec and VecDeque APIs I'd like at least a summary comment explaining what this method does, why this design was followed, alternatives, and addressing the issues mentioned here that have received zero replies: should this method be to ? : naming issue: why s instead of elements? why instead of , etc.\nconcern rationale-and-vecdeque Just gonna formally register concern above\nNot an issue with the method per se, but it may need to be very clearly documented that the reference is not supposed to be to an item that is in the already, as it creates impossible borrow-checker conundrum. Users coming from the C world of pointers but no proper equality comparison, may be confused by this method, e.g. The name mentioned previously would help.\nas the proposer for FCP, do you have thoughts on concern?\nMy thinking is that the suggested by would sidestep most of the issues here.\ncc re.\nI don’t have a strong desire for this particular feature myself, I proposed FCP as an effort to reduce the number of features in \"unstable limbo\". That said: Regarding , sure, I don’t see a reason not to add it there as well. as proposed in sounds good to me. It is more general, and goes with precedent of also taking a boolean callable predicate rather than relying on . (Even further, the precedent of not having a method like that would rely on .)\nI notice two things: are a lot of methods similar to this we could add, and its not obvious to me which set of those methods is the ideal set. has sat in FCP concern limbo for 8 months without anyone complaining. I think we should not stabilize this just because it exists, but instead someone should come up with a well justified explanation of exactly what the best \"find and remove\" set of methods of vec-likes would be.\nGood points. (which is stable) and also fit the \"find and remove\" description, and we had a similar concern about the combinations of filtering v.s. non-filtering and self-exhausting on drop () v.s. not.\nresolve rationale-and-vecdeque I don't want to personally be on the hook for blocking this any more\n:bell: This is now entering its final comment period, as per the ."}
{"_id":"doc-en-rust-f36d56ca8a5b853dddef1e388eccc3f4996314ced95e190f320b6523af18a2c2","title":"","text":":bell:\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. The RFC will be merged soon.\nI still think this should be called instead of .\nMy problem with that name is that it only removes the first matching item, not all that are (though I haven't read the relevant RFC to know whether the name has been hashed out already; I assume it has been).\nI don't think the naming issue has been resolved. The implementation is still using the name. then?\nCan someone clarify what the status of this is wrt. the conversation above?\nAn example: I'm writing a proc macro attribute, and amongst the tokens, I expect other attribute to be there. This would be useful to add:\nUntil we sort this out, you can use\nPing. What's the status of this? Could we stabilize something?\n? Given we already have drainfilter for accepting a predicate, it would be nice to have a method that removed a single object from the vector (if there). Removing something from a vec is exceedingly common code. Getting the position and then removing that position is longwinded for such a common operation. (Btw, I think bit of naming is excellent as it highlights that there may be others still in the vec - a method name that prompts one to think is a good thing.)\nI use for this, and haven't found it too cumbersome. It differs in that it removes all copies of a given item, but is very easy for many purposes.\nRetain everything but the object? As work-arounds go that's shorter, but it's not ideal for expressing intent. Still keen on and .\nJust to bring up a different opinion: how about removing this method instead of stabilizing it? While yes, it would be convenient to have, it might not be worth it. For one, is not a good name, as many already said. The name doesn't imply that the first item from the start is removed. is better in that regard, but still doesn't feel completely right. More importantly, if we have , we should certainly also have . Having one but not the other feels arbitrary to me and makes for a surprising API (that's bad)."}
{"_id":"doc-en-rust-a6a233343c4941fe4fb1380f06eae3729603f6c6f6d97ff568c7be2c0e92d2d6","title":"","text":"Similarly, we would also want to add the variant of both of those methods. Potentially, we also want to add a variant that removes all items equal to the given . And as also already mentioned, we can also add all those methods to . And why not (without the versions)? Consequently, we would have to add 10 or 15 new methods. Adding fewer would make the API inconsistent IMO. All the functionality can be implemented with very little extra code with iterators.\nHow do you propose this be implemented with iterators? How about this signature: This uses to make it clear exactly what is removed. The argument and the return type makes it clear that we remove many items. The user has the option of how many to remove ( means all). The returned iterator can be implemented efficiently by shifting the items and then pulling a similar trick (using ) to to yield the removed items.\nalready mentioned this : I think that one is too complex. Especially when considering the call site, I think it's fairly hard to understand. And the name still does not imply that the search begins at the beginning, which is a big nono for me.\nRemoving an item from a vec is a very common codepath. Somehow it needs to be a one liner. Having swapremovefirst() and not having removefirst() would be nudging people in the direction of great performance. That seems quite rustic to me. swapremovelast is interesting as there maybe no swap needed if it happens to be the last item - cute. Just have those two functions. That’s the 80% case covered. People who wish to maintain order will just have to have slightly more code. On Fri, 15 Nov 2019 at 19:20, Lukas Kalbertodt <:\nI don't understand the focus on removing here. Vec has a lot more members taking an index than and , and only a few to get hold of an index value ( variants and , sort of). Most of the complication in the \"workaround\" for this remove_item is finding the first index of something: v.iter().position( n == 2) Not too bad, the reminds you it's a linear search, but could be easier."}
{"_id":"doc-en-rust-2bfa86423016dc0b4d2cd712595eb9def72ae5df65ba94c9342a5feb4db8696b","title":"","text":"<delWorse for the last index: ().rev().position( v.len() - i - 1) Contrast to the and in that famous vector called string that (ugly names but at least they convey that a search is involved). I've vary rarely needed this, I don't advocate making linear searches easy, it just seems more useful to try to make searching easier, before making search-and-removing easier.\n(so does ). And even if it didn't exist, that has no relevance to whether should exist or not, they're separate features, so they can both exist, it isn't either/or. (I personally have had many cases where would have been useful, it's a common operation in any language.)\nWaaait! It's getting stabilized without fixing the confusing name! Please please don't call it , as this is the same name as in other languages that can remove item from an array by presenting an item from the same array. Rust's version can't do that due to borrow checker and it's a trap for users.\nI absolutely wouldn't call it a trap.\nIt seems like many people agree that the name should at least be up for debate again. Really unfortunate how the name discussion was somehow forgotten during FCP. So I guess we should revert stabilization as soon as possible so it won't end up in beta?\nSounds reasonable. Maybe someone wants to volunteer to lead the process about settling on a name for this ?\nThe next release is scheduled for Jan 30th. So we have about 3 weeks to figure out a new name.\nI went through the thread again and it seems like the following names are suggestions for the method as it currently exists: (iterators have \"items\", Vec has \"elements\") - Personally, I would absolutely include , as that's an important information and . I have no preference between and . However, from reading the thread again it seems there are plenty of other concerns and suggestions that haven't been resolved yet: Adding similar methods: ? ? Replace the method with:  (although I don't understand that one. Is it just a with flipped predicate? In that case I don't think it's useful. If it just removes the first element, then absolutely needs to be in the name IMO.) Do not stabilize this method at all: ,\nmentioned : also raised some more concerns , and I raised some concerns ."}
{"_id":"doc-en-rust-eb26f99012e5d90e23376380eb3ffa91828c552e642c5b8e9e77faa562982d56","title":"","text":"I don't see where these concerns have been resolved. From re-reading this whole discussion, it isn't clear to me what the goal of adding this method is nor what problem does this method solve or whether this is a problem worth solving. What's more or less clear to me is that there is at least some design work to be done to at least ensure that libstd exposes a consistent API, and that sounds like this would warrant an RFC to me. The current discussion about using a method hints that these APIs might not only want to be consistent for the ordered collections (Vec, VecDeque, List) for which a notion of a \"first\" element makes sense, but might also want to be consistent with the e.g. and methods of slices. The main arguments for FCPing this appear to be that this has sit on nightly for too long without anybody complaining, and the main argument for stabilizing this has been that this has been in FCP for too long. I think it would be better to just encourage and support those that want to land this feature to write a small RFC for it. If somebody is interested in doing that, I would be able to help and give feedback.\nUnless a concern is made with by a relevant team member, then it won't stop FCP. And it won't go into FCP unless the majority of team members have voted for it (and there aren't any formal concerns listed). So the fact it passed FCP means that all relevant team members that they were okay with the current design and did not have any outstanding concerns at the time. Things do not go into FCP simply because it's been \"sitting around too long\". Of course if any team members do have any concerns, now would be the best time to make them.\nMistakes happen. And to me this thread clearly looks like many concerns were overlooked accidentally and no one explicitly marked them as concerns for rfcbot. Luckily those mistakes were caught.\nReopening because\nThe current signature is missing a ?Sized bound. Could I ask for a PR to fix the bound and add a test that covers remove_item(\"...\") on a Vec<String? This use case was requested in and\nSeparately: I am leaning toward removing removeitem."}
{"_id":"doc-en-rust-20b648530e897677a59e79e0fafbf3838590a3525cc67cc4074a2b3eaad420b5","title":"","text":"I agree with and The currently design involves: start with a reference to a value not in the vec, use its PartialEq impl to do a linear scan, remove the first found, shift everything after the removed element. To generalize almost all of the discussion above, people are questioning whether the conjunction of all 5 of these decisions is really as common as a name like removeitem would suggest, whether a different permutation of choices might be more widely applicable, and how to adjust naming to leave room for all the other equally or more common permutations: ones where the ref we want to remove is a ref to a vec element, or we want to remove by FnMut instead of PartialEq, or we want a binary search, or we want to remove the last, or all matches, or we want the more efficient swapremove behavior. Fortunately Vec already supports all permutations of these use cases equally well, with nice independent APIs for searching and removing. Many people have voiced opinions equivalent to \"removing an item from a vec is so common that there absolutely must be a function for it\". I think what they mean is that the union of all permutations of the above 5 choices is common, which is true; they don't necessarily mean the specific choices that go into removeitem as it exists would justify a method specific to those choices. points out that satisfying the set of use cases which all together are common would take a much larger number of new methods.\nPer , I think we should go ahead and remove . fcp close\nThat is not what I meant. When I said that I need in my code, I meant exactly that: that I could take my existing code and replace it with and it would have exactly the same behavior, because I really do need specifically, not the other fancier methods. I'm perfectly fine with changing the name so that we can accommodate other fancier methods in the future, but why would that mean that we shouldn't have at all?\nfcp cancel\nproposal cancelled.\nPer , I think we should go ahead and remove . fcp close\nTeam member has proposed to close this. The next step is review by the rest of the tagged team members: [x] [x] [x] [x] [ ] [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."}
{"_id":"doc-en-rust-4fde0a489073ea47e374bf0dac8e839e7a7f929d1784009e1e4f92f84cc4743e","title":"","text":"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.\nChecking KodrAus’ checkbox per\n:bell: This is now entering its final comment period, as per the . :bell:\nThe final comment period, with a disposition to close, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed.\nSince we've merged the deprecation would we like to close this tracking issue now? Or keep it open until the unstable deprecated method is removed entirely?\nI think keeping this open until we removed the method is a good idea. How long do we want to wait with that by the way? I guess a couple of cycles is sufficient?\nBefore closing, it would be great if someone could suggest a \"one clean and obvious\" way to remove the first/last occurance of an item from a Vector. Irrespective of the arguments made here, a method removing the first/last occurance of an item is provided across all major programming languages, and is to be \"expected\" Anyone new to rust is bound to google \"remove from vec rust\" and end up on this discussion which would only leave them more confused.\nshould answer those questions. But here is a copy of my answer for convenience: You can of course handle the case however you like (panic and ignoring are not the only possibilities). Like the first element, but replace with . Remember that has a runtime of O(n) as all elements after the index need to be shifted. has a runtime of O(1) as it swaps the to-be-removed element with the last one. If the order of elements is not important in your case, use instead of !\nIt might be worth adding more examples (maybe all of the ones above) to the docs.\nI'd like to add those to the docs, should they go along the example that we currently have?\nWhat examples are you referring to? I could imagine those \"remove examples\" either going on the type (as a new section \"Removing elements\" or something like that) or directly on the method (below the existing docs). And by the way, feel free to add (parts of) my text/examples verbatim.\nThank you."}
{"_id":"doc-en-rust-04df2af8400b69a3b2a8a0e9f7e8cd1fdccfe6b7f6da1d2bca38ac39f7b1d5c8","title":"","text":"I was referring to those \"remove examples\" as to whether I should append them to what we currently have in docs for , put them somewhere else or perhaps modify examples for to include removal of specific element\nThat sounds fine to me. Feel free to just open a PR and we can still see about the specifics then :)"}
{"_id":"doc-en-rust-22da7a749da9ea5de82010003a3d02065aadf76edc99be61c6ff0e59a3f73108","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. -- On stable the code produces the following error as expected: <details<summary<strongExpected result</strong</summary<p</p</details<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</detailssearched nightlies: from nightly-2021-10-04 to nightly-2021-10-23 regressed nightly: nightly-2021-10-16 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.1</summaryHost triple: x8664-pc-windows-msvc Reproduce with: </details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nAlso ICEs on beta. label regression-from-stable-to-beta\nInteresting, this is rustc now, right? There has been as similar rustdoc ice:\nYes, this can be hit with or for example. I tried running the code in , but it seems to have been fixed by now.\nclaim I'll try to take a look at this."}
{"_id":"doc-en-rust-fa5de52d3ace12677445254bb6cdb3896b1f26f61b4e6e81d95ebf54de71f95c","title":"","text":"Steps to reproduce: The output of is: does as suggested by the message, but that fails too (as expected): Proposed fix: in the beta and stable channels (i.e. whenever is forbidden), the message that suggests adding should not be shown. (Clean up the test case with .) CC\nGonna milestone this real quick, as it seems quite important.\nI might be able to whip up a quick fix, though I'm not 100% sure about testing it properly ... (I've never actually tried building something for a non-dev release channel before...)\nafter chatting with it seems like I have a patch, building it now\ngonna leave to it\nHello good Rust folks :smile: Before the beta, I used which is in . Is there any way to use this trait during the beta ? I'm not sure how I can get the code to compile. Thanks for any tip / hints you can offer :+1:\nHi Commenting on random unrelated issues is usually not the right thing to do. You should rather open a new issue, or ask on . But to answer your question anyway, that trait only has : … and is stable and can be used on beta. So I’d recommend you copy/paste the trait into your code, or make a function.\nThanks for taking the time to answer. I appreciate it. I don't see how this is unrelated. This is related, since the code I'm talking about used to compile with and the compiler suggests to do that, during the beta period. Thanks for your tip on copying the function :+1: I guess I'll just do that if nothing better is available and change this again when the trait is stable.\nThis specific issue is about fixing one of the compiler’s error message, not about fixing code that triggers that error. It really helps everyone to keep discussions on topic.\nAlright. I understand. I'll make sure to open a new issue or go on StackOverflow next time if appropriate. Thanks again :+1:\nThis doesn't seem to be properly fixed in the beta channel. I'm still being recommended to add in the errors, and then told it's not available in the beta channel. Rust version: The code I used (snappy example in the docs with the extra addition on the first line:\nThis happened after Beta release."}
{"_id":"doc-en-rust-b4e439e7e28004a888d7eeea745c4600205c8125bbf9c901393d71174d4795f9","title":"","text":"We'll see the effect of this patch in 1.0 and afterwards Beta, etc.\nWhoops, I thought this made it in before beta. Thanks!\nare there plans to release updates to the beta channel within a given 6 weeks cycle? Either this one or in the future.\nI'm certain there will be updates; see discussion from last night here:\nSo how does one fix this error? I'm a new user of the rust library and I can't seem to use the collections library during the beta due to this problem. Given this git issue is a top google result, it would be nice if there were a solution here. Edit: Looks like the solution is to switch to the rust nightly. Is the entire collections library off-limits in the beta?\nby design, you have access to the parts of that are re-exported from (and are stable)."}
{"_id":"doc-en-rust-429e75f84d9496dd224466f70d13aa41d9d80315bf8b55686a148d7b3ff535a3","title":"","text":"Rust compiler (rustc 1.1.0-nightly ( 2015-05-14) (built 2015-05-14) fails to compile this source: With the error: I can reproduce this ICE also on\nReduced it a bit:\nThe broken IR:\nLooking through it quickly, it seems like the order of the cleanups is messed up? If is then from the switch we go to the label which just jumps to where we memcpy the value for into the alloca and then continue to the label. This is where the problem is since it tries to call on the value returned from . But that's the thing, we wouldn't have called in that arm of the branch and hence shouldn't need to call free either.\nAdding a block around suppresses the error. I feel like we had a similar problem not too long ago.\nThis is \"caused\" by the micro optimization for dereferencing owned pointer rvalues in . Since is the \"trailing\" expression for the arm its cleanup will be scheduled in the same scope as the match expression. cc\nEither way, this is a dupe of I believe had an idea for a fix.\nit's simple, we remove the micro-optimization and always return an datum from . The possibility of returning datum also caused issues with field accesses - see for that fix. We have a static type system and the / marker types are there for a reason. If there is no answer to \"how is an rvalue dereference or field meaningful?\", then the return type for both of those should be ."}
{"_id":"doc-en-rust-d7e7816e02bbc967b3ca099b4827bb4b3ad9f0b4fb4b571c4a6743d6f02ba81f","title":"","text":"Original testcase by (reduced from ): The debug log reveals that a (shallow free) cleanup of the rvalue is scheduled in the scope of AST node , while the dereference expression itself has id : reveals that id refers to the entire function's block: This means the cleanup of a value valid only within a match arm is scheduled outside the arm. cc\nDupe of Leaving open for now but we can close either.\nThis is caused by a micro-optimization specific to dereferences of rvalues. Is this used oftenly enough to justify its existence in the first place? Even if it is, I guess we can disable it in problematic cases like this, where the temporary scope of the match arm's RHS is outside the arm.\nI think we can probably remove it, in general removing special treatment of seems like a Good Thing\nTriage: this still ICEs.\ncan you point me/us at the micro-optimization that you mentioned above, so that I (we) can try removing it ourselves and measure the impact?\nI only vaguely recall this issue, but I'm pretty sure I was talking about .\ntriage: still ICEs.\nIndeed, it doesn't even need : Does this at least continue to ICE even if LLVM is compiled without assertions? If not, we may want to up the priority on this ticket."}
{"_id":"doc-en-rust-146312829290b27802b9e72c4c1d00d7d6e734a8e4dd04d06994a15e12da085f","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<!-- query stack: [resolverforlowering_raw] getting the resolver for lowering --\nthis probably crashes since but I haven't verified that yet\nsmaller\neven smaller"}
{"_id":"doc-en-rust-e2ace22260b74516fbc755ffdb010cc809dd15bd5335cb5346fad0307d8fe994","title":"","text":"Rustdoc on [nightly documents][1] methods have signature of as while it only has to document it as . ! On [rustdoc stable][2], things are normal: ! : Version 1.49.0 ( 2020-12-29) [1]: [2]:\nI'd like to investigate this :)\nsearched nightlies: from nightly-2020-12-29 to nightly-2021-01-22 regressed nightly: nightly-2021-01-09 searched commits: from to regressed commit: This regressed in , so this is probably caused by\nThis also affects Where will generate:\nSo a few observations: which displays mutability in patterns, causing to be displayed the mechanism for detecting and eliding works by , but as returns instead of , the comparison fails and displays the type.\nI see two path to solving this bug: an option for to not display the mutability in patterns revert cc what do you think?\nI would prefer to go for 1, there's no reason to have two completely different functions for pretty-printing.\nAssigning and removing as in the prioritization working group.\n(now a beta regression)"}
{"_id":"doc-en-rust-ef821f466a0b97e8b9e50bea4d4c67b6f3bca8ff4ac55e2a8a5cddd17bab5c8c","title":"","text":"New contributors haven't use before, so there's no reason for them to read the changelog: nothing has changed.\nI can tackle this.\nthat would be great! To get started, take a look at . In addition to adding , also add . You'll have to move from to so you can access it in . You should also double check that the changelog warning isn't printed during the command itself. I'm not sure exactly how to do that without reading the code, but I expect it to be a simple or something like that."}
{"_id":"doc-en-rust-afd27268ea89572f7b26598fdc232f6d92e5c6803f0f99de6f58b0b3f16ac3b3","title":"","text":"is unacceptably slow. Consider this code: When trying this code, make sure you have enabled release mode. On my local machine I see this output: So is 15x slower than . My rustc version is . My OS is Debian Stretch x86_64\nlabel +A-process +I-slow\nOn windows they are both equally fast, so it seems to be a unix-specific thing. Also note that these two programs are not equivalent, as also reads , while you don't (this probably introduces some overhead). Still seems worth at least investigating.\nWhat's the magnitude of slowness here? and what's the time taken on windows? Here's it on my computer, built with release mode My computer : Apple M1 Mac Mini, 16gb RAM and 8 CPU Cores\n. I just compared old rustc () and new one, with this fix (). I see that the bug is actually fixed, thanks a lot! Moreover, both benchmarks became faster"}
{"_id":"doc-en-rust-a807c1dab372d105219deafe7e918540761b044ffca4d9b7fabfa5c5e9c806db","title":"","text":"For this code: You get the following error message: The suggestion may be excused to be not 100% perfect, but here it suggests to add an use statement despite that same item being imported already. What I want is this exactly: that it removes stuff from the suggestion list that is already being imported. Note that changing the glob import to a non glob one doesn't change anything.\ncc\nWhy is that even an error?\ntuple structs have private fields by default, you can't construct instances of B outside of the foo module.\noh ^^ maybe we should simply modify this error message then to say that the \"function\" is private?\nIt already says \"constructor is not visible here due to private fields\". That's okay, but maybe you might have meant another B from another module or something. However, the candidate offered is not any better as its the same one you are attempting to use.\nReopening to track \"removal of suggestion\" work for pub tuple structs with private fields."}
{"_id":"doc-en-rust-f490521c52d25c7603a2622aadcc7005d494ad96916fc9287f4e5f1aa9ce79cd","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. --: Not posting the entire 1.7K lines backtrace :upsidedownface: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nYou can also reproduce this in the rustc repo itself where will encounter the error with\nReduced: label F-typealiasimpl_trait\nFound another repro I think: this one bisects to\n`\nprioritize\ngoing to also link and as other reports of the same issue\nWG-prioritization assigning priority (). label -I-prioritize +P-medium\nOk, after a bit more back ond forth , I'm tentatively bumping this issue to P-critical and raise these questions (echoing the comments from the discussion): would it make sense to revert ? cc or would it make sense to revert (which IIUC leaked in the std library an unstable nightly only feature) ? cc Next week Rust 1.72 will be released, artifacts are going to be build real soon, I think. Thanks for additional comments to help improve my understanding of the context here. label -P-medium +P-critical\nThe underlying issue here is an issue with TAIT. was an implementation-only change simplifying some backtrace code in that was made under the assumption that TAIT was reliable enough to be used inside . As it is not user-facing it should be easily revertible. So the question here is whether it is safer to get TAIT working (potentially by reverting ?) so it can be used internally or to just hold off on using it until the issue has been resolved, reapplying once that happens. I have no compiler experience, but my initial hunch would be that the library change is preferable for now. I'll get a PR ready until tomorrow, unless someone beats me to it.\nshould not be reverted."}
{"_id":"doc-en-rust-63a20fccbc8b7e251be9fb481417bf99230142f99fc0e27367921a4109ea0b30","title":"","text":"All it does is cause us to now eagerly reveal opaques that were being skipped over during normalization, which means that we're just not hitting this code anymore: It does not introduce a bug, it just reveals one that already existed. I'm gonna use the minimized example () here. What's happening here is that we're generating a drop shim for that looks like: which then tries to validate that . However, it has type , where is a , which does not hit the code I linked above. Before , we'd emit something that looks like: which is a field that is incompletely normalized, but does* hit the code above.\nSubmitted the PR reverting : .\nfixes this issue by not considering mir validity on shims until they have been optimized, which uses the reveal-all param-env for that shim. This ICE shouldn't be possible to trigger without , since it has to do with one of the intra-pass mir validations that are only done when that flag is active: I don't personally think that needs to be reverted, either.\nThis was also possible to trigger even before using an associated type. The test in exercises this too."}
{"_id":"doc-en-rust-cd34ad2c493ec5a906302f20259163687870f739e42d7eb79de1288707dd2e75","title":"","text":"The expansion of and both currently cause code to fail the stability check because they expand to reveal unstable implementation details. A seemingly reasonable solution to this would be to just not run the analysis on any code that has been macro-expanded. cc\nI definitely agree with this approach: we should be able to annotate a macro with a stability level, and that's what should count for its users. Do we have a way of telling what part of an AST was generated via macro expansion by the time we get to linting?\nMostly; there's the field of a : for normal code, for macro generated code (basically containing the backtrace of macro invocations that led to that point).\nOK, that makes this sound like a pretty easy fix. I'll take a quick look at it tomorrow (unless wants to?)\nHm, this seems slightly subtle, since the contents of a macro would then never be checked for stability. This differs to a conventional function, e.g. given , won't warn, but the contents of is still checked, while where is just never checked. (Of course, macros and phasing are both feature gated so you have to opt-in to instability to use non-standard macros anyway.)\nGood point. Also, it looks tricky with the current infrastructure to even lint on the macro invocation -- the backtrace of macro expansion does not appear to link to the def_id of the macro (or give any other way of getting at the macro's stability). Nevertheless, I think we should bail out of the lint when we hit the results of expansion; those should be checked, if anywhere, at the site of macro definition. One other question: do syntax extensions also produce the span information you mentioned above? I ask because original problematic cases are written syntax extensions. If not, is there some other way of telling that an expansion happened?\nI have a patch ready that bails of out the lint on expanded code. This also seems to mask uses of . If y'all are ok with this strategy for now, I'll file a PR.\nSounds good to me. Thanks!\ncc"}
{"_id":"doc-en-rust-f1af63fde991742bd2e7647680455cd9de2d4013796eaaf30b2010e671b9d1c0","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 --\nSlightly minimized:\nI understand the issue here, and have a solution but it might not be optimal. claim"}
{"_id":"doc-en-rust-46b76fc5f0273a557f44138b31ff14b36d3a477f1040c119c058ac62ccee6c97","title":"","text":"suggested an optimization for , and it was implemented in . However, for some reason, was not optimized the same way: It can be implemented in terms of : Is this deliberate or just something that no-one noticed?\nBy the way, you don't need to open an issue if you're about to open a PR. Just include what you would put in the issue in the PR!"}
{"_id":"doc-en-rust-c0358fb5f98a3b0d5b83cee967727a06b1fd5bdaacbc478a0f52966fa7eeee49","title":"","text":"The multi-line errors should be extended to include this testcase. missed this because the didn't go through . I tried but that didn't work either. If someone can point me to to where to catch it, I can probably fix this too. cc Code: Error: Change to:"}
{"_id":"doc-en-rust-2da5fa86b84bf416d9b670af0c4e7d9c0ccd4cda593660d7d16436e913a6382e","title":"","text":"Following , we realized that rustdoc users would prefer to have a syntax extension rather than using plain HTML to have warning blocks. suggested the following: suggested: What do you think? cc\nPersonal Opinions: The first style will look fine for short forms, but I'm not sure for longer text. A possible syntax: Which to me pushes the text too far right. Not having any spacing, but just separating with newlines, seems hard to parse at a glance what is part of the WARNING, and prevents multiple line breaks inside the warning. Also, it's not as extensible. INFO can be , but if we ever want more extensions, they would increasingly possibly conflict with other things. The second style makes it immediately clear what is part of the block, and is unlikely to accidentally conflict if we ever want to add more block styles. It also supports multiple lines or inner blocks trivially. A final advantage is that it may support nested blocks, in case those ever come to be useful. Overall: I prefer the second form, both aesthetically and for future-proofing\nI think I agree with in preferring the second form. I like the first form's simplicity, but it also seems surprising that is treated as a 'keyword' and will change the formatting of the docs.\nThat's why we have this debate. :stuckouttongue:\nI personally actually prefer stabilizing a CSS class, I think we should do more of that, just because parsing can get annoying. But this is not that hard to parse anyway. The problem with is precisely that you can't scope it easily: what if you want to add code blocks? bullet points?\nThe problem with this is it ties rustdoc to the HTML backend; like I said nothing rustdoc currently does guarentees that it will generate HTML from the markdown. Changing that means that to make the JSON backend have the same info, we'd have to add a full HTML parser to rustdoc just to read the HTML in the markdown, because pulldown does not parse HTML for us. I really think we should avoid making the JSON backend a second-class citizen.\nAlso there's not much point to this if it's just a little CSS IMO, you can add that yourself with and it will look just as good and be more flexible since you can control the styles yourself."}
{"_id":"doc-en-rust-750e7c681f4102792b3611241ddcbc147822060286ee625b8e928ddde584f36a","title":"","text":"I'm not a giant fan of the syntax because it looks odd when rendered by anything other than rustdoc, which I'd rather avoid, one of the major design concerns for intra-doc links was compatibility with other markdown parsers:\nSo, I agree, but I'm not convinced that the warning class is something that needs to be surfaced in the JSON backend as anything special. Also, bear in mind, HTML is a part of markdown: valid HTML (well a subset of HTML) is valid markdown. Users already can , and they do that in many cases. Markdown parsers already need to be able to handle HTML. There's nothing new there. Whatever consumes the JSON backend will need to be able to handle that too. I mean, yes, in theory, in practice people don't do this because of the barrier to entry (you have to get your tools to use that, including )\nAlso, this is incorrect, pulldown absolutely parses HTML. It has to, like I said valid HTML is valid Markdown. It doesn't parse it thoroughly, I believe you can mess it up with sufficiently complex HTML, but it parses HTML. What this changes is subtler: up till now you did not need any particular stylesheet to acceptably render rustdoc markdown from the JSON backend on your own (just use your favorite markdown renderer's stylesheet), but now you will need other css classes to handle rendering warnings as warnings.\nI do not agree that this is a problem. I've used Phabricator's implementation of this approach happily and it is by design that warning banners are one paragraph. It is not the intention that you would put entire sections of documentation into a warning banner. They are for a brief callout. It's fine to refer to a subsequent section of the documentation from the callout if needed. I suppose this is a matter of taste but it's one where I believe the opinionatedness of the syntax is a positive thing.\nSo I discussed this a bit with on the side, we agree that the effect on the JSON backend isn't major since HTML is already a subset of markdown and docs use HTML already (especially for images and tables). My position is as follows: I strictly prefer HTML over some other scoped syntax with nuances people have to learn. I don't think there's as much value in unscoped syntax which makes my position \"HTML or nothing\", basically."}
{"_id":"doc-en-rust-dec4ce823c8be44080dd52f4329cd82509f0245db429e2372e378f7f940d6712","title":"","text":"I'm not wholly against unscoped single-line syntax. We and syntax in W3C specs and you invariably need to add more stuff to it (there's an HTML class in these specs for this reason). Furthermore, Rust has a strong culture of wrapping text, so this means we need to work well while wrapped, and that means we're again introducing some form of scoping mechanism (e.g. indenting the text), which editors will have to learn, as well.\nI don't know about admonitions specifically but there seems to be something of a community habit to use \"magic tags\" on fenced code blocks for this sort of features (e.g. github has a tag), maybe that could be an option? I don't know if pulldown_cmark has a hook for manipulating code blocks but… So a warning would be or maybe the tag would be to leave room for things like note/todo/danger/… Alternatively, take a gander at how other markdown implementations extend the language for this sort of features? e.g. seems to be using for admonitions.\nHmm, but is still for code, even if it has some extra behavior. Aside from the design concerns, this would be feasible to implement: we just extract the language string from the code block with pulldown.\nCould you use something that's already built into markdown? For example, rustdoc could take and render it as an admonition.\nThat's what suggested: to use markdown and make some changes on rustdoc side. I think the codeblock approach is the best personally.\nMy bad, I didn't see that.\nI wonder if it makes more sense to add this as a proc-macro. Rustdoc can still provide the CSS classes and things, and you could use them with HTML directly, but you could use or something and it would expand to the correct HTML tags and classes.\nMight be better to have a then, no?\nIs that going to be a special header similar to the \"unsafe\"/\"experimental\"/etc ones, or is that going to also be used within docs in an order-sensitive way? If the latter we should probably just use a CSS class; mixing and is ugly\nAgreed."}
{"_id":"doc-en-rust-0401f4aca5f75b95bccb3c9f0c1382f7d896e23af0bafe46936c5b01ce984214","title":"","text":"Among the suggested ideas, my favourite one remains the code block with \"warning\" as tag:\nYeah, but triple backticks is also for preformatted text without further markup, so you won't be able to e.g. use text formatting (or other code) in there\nTrue... Finding the right syntax is much more complicated than expected...\nThat's the issue of using markdown, for all that it has a pretty nice baseline syntax it really was not designed for extensibility.\nWe can always use : it'd allow to have text formatting inside it.\nI would use , it's not quite kosher to invent arbitrary HTML tags (though you can use Custom Elements, which is more heavyweight)\nSounds good to me. It's funny because we kinda came back to the . :rofl:\nI just thought: we could use tag in the markdown and then transform it into in the generated HTML?\nMy main objection to all of these is that rustdoc shouldn't be adding custom markdown syntax that no one else supports. Any new syntax we use should look reasonable even if rendered with the default renderer.\nWell, it remains valid markdown since it's HTML (even though it's custom tag). I'm completely fine with , but it might be simpler/better for users to simply write .\nComing back to this (because of ), it seems like the conversation kinda agreed on adding a CSS class directly and then it would look like this in the docs: . I'll send a PR in the next days and then we can open an FCP to see if everyone is ok with it (and if not, we'll have code to help the debate).\nThis indeed seems like a better solution than the HTML block. It also plays better with something said about not linking it too much too HTML. This will look like a proper warning or note, mostly independent of the HTML generation.\nThey also seemed to not be too favourable to anything that needs some extra parsing from rustdoc iuc. I'm fine with bot the github solution and the CSS class.\nMaybe one more comment to make here. The note-taking app, which uses Markdown also has a similar syntax to create these blocks. It is called . It uses a syntax similar to the syntax that is used for doc intra-links currently, and it is fully compatible with them."}
{"_id":"doc-en-rust-905d2f3b7c6b013fa7467fd80d5c43168bffe6d3d80604ac80788220d4eb9b1e","title":"","text":"I am uncertain if this is any better than what suggested from the GitHub syntax, but because of the similarity to the doc intra-link syntax. I do feel like this might be interesting because it should go well with backwards compatibility. However, this may look worse than the GitHub syntax solution when not going through cargo doc.\nI thought I'd already left this comment, but I'd really like to avoid adding more markdown syntax where possible. This feature works fine without special syntax, I don't think we need it. edit: copying over the reasoning from the :\nAlthough, I might not agree fully, I can fully appreciate and understand the reasoning you left in the corresponding PR. Still, I do think it might be worth to standardize some kind of syntax for some kind of warning block. This does not actually require customized markdown. Alternatively, I can suggest adding the GitHub flavor with emojis to the . This may help in standardizing short form warnings and notes within documentation. We could for example propose to standardize: which should look like the following I do value people's opinion on this. Is this a possible compromise?\nThat's a valid alternative, I think the yellow color is pretty important though, and it's useful for themes to be able to make styling decisions about warnings so I do think that having some way of marking it is important. I just don't think the way of marking it should be some magic invocation as opposed to CSS classes. (And I think that the bar for a feature that is adding new semantics to the Rustdoc markdown parser is much, much higher than that of one stabilizing a CSS class)\n100% agree. I will look at the Rust API guidelines issue and possibly an RFC to rust to track the adoption in GitHub and possibly eventually merge. Thank you :smile:\nBeyond all this discussion of third-party tools, I'd really like to make sure that whatever new syntax and presentation we add to rustdoc can also be to [mdBook]. That way, when the standard library starts using callouts, we can make sure the same style also gets used in The Book. Mostly, The Book seems to just use blockquotes, often with headings like [this one about ownership]. mdBook doesn't do anything special with it: it's [just a block quote with a header]."}
{"_id":"doc-en-rust-c904caf33bd46cec9a84e48d777b4f48ec308eec9cfa53ff08ad48d46f41d2fc","title":"","text":"[mdBook]: [this one about ownership]: [just a block quote with a header]:\nThis is a good point. Once we have something merged here, I'll send a PR there to have an equivalent.\nCC\nI'd be happy to add some CSS rules to mdbook if that is what you are proposing.\nYeah, it is.\nFYI, using a is not semantic and Microsoft GitHub is setting a bad precedence. — CommonMark Spec v0.30, denotes a in Markdown and is rendered as such. — W3C HTML spec, Unless you are quoting a source, this is not the correct element to use. While I disagree with even using altogether, at least some tools out there are at least translating the blockquote in admonition context into a (div has no semantic meaning which is unfortunately the best HTML option for admonitions). It would be ill-advised to follow Microsoft GitHub’s Markdown syntax fork&mdash;especially with their disregard for semantics. Similarly using a block would also be breaking semantics as an admonition is not preformatted text. CommonMark does have that could be used if the solution was preferred. There’s also other reasonable options noted here that don’t break semantics.\nI agree that block quotes for callouts are bad, and would like to work with mdBook to roll out a common syntax (probably ) that will replace the ad-hoc, unsemantic markup that they use right now.\nUsing is what we agreed upon in The debate now is on the look itself.\nUnfortunately isn't great because markdown has a \"boundary\" when HTML tags are used. I wanted to add a warning indicating that users probably wanted another trait, but intra-doc links don't work (which is the correct behavior per markdown spec).\nWorks perfectly fine though (well, minus the UI bug I just discovered haha): ! I used this code: I'll send a PR to improve documentation.\nAh. Well I suppose the issue wasn't with intra-doc links, but with inline code blocks. What I tried was that but with bar`, and it failed.\nWorks too: !\nI opened which adds extra explanation on how to use markdown inside html tags. That should solve your issue.\nThat note is exactly what I was just looking in to. I had it inline, given my familiarity with HTML. TIL that matters."}
{"_id":"doc-en-rust-1196006ec2219d0730aa48521bbdc7cae854ede34ccfdf1d5ca56b4ee83cd30c","title":"","text":"It doesn't hurt to have it and if it can helps users, well, why not doing it. :)"}
{"_id":"doc-en-rust-a66d35baaca2ce2d7249a2f58322c380b6094c5108caf32fcb400bf098eef8b0","title":"","text":"cc\ncc\nThis was caused in the TOML refactor in Cargo, the fallback support to support malformed is likely broken.\nFixes are sent to Cargo, I'll send PRs to rust-lang/rust when they're merged\nSubmodules landed!"}
{"_id":"doc-en-rust-38180ef35a6d9c74f6afc480e242b17e4ee949d2240e6931e2a4883945375232","title":"","text":"https://crater-\nsearched nightlies: from nightly-2024-02-01 to nightly-2024-03-20 regressed nightly: nightly-2024-02-10 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.8</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </detailsprobably\nWG-prioritization assigning priority (). label -I-prioritize +P-high\nMCVE"}
{"_id":"doc-en-rust-86145dda3b6fd95b4efbdb679c46b9803ebc45ffea7ba9a1d53d1d81b4427672","title":"","text":"The following code fails on stable: When compiled in release mode, the assert is optimized out by LLVM even though it checks the exact same condition as the other assert, as can be verified by testing in debug mode. Note that it's theoretically possible for the stack to be aligned correctly such that the bug is suppressed, but that's not likely. The 256's can be replaced with larger alignments if that happens. The bug is caused by the impl of copying to the stack with the default alignment of 16. ()\nand seem related\nThis is a soundness hole.\nSo... I guess the problem is that the that rustc emits for the unsized local doesn't use ? That's... kind of bad, because it doesn't look like even supports dynamically setting the alignment: If this is correct, the issue should be renamed to something like \"unsized locals do not respect alignment\".\nA way to fix this would be to change the ABI for dynamic trait calls that take by value to always pass by address. When the trait object is created is where the trampoline function would be generated, so there is no additional cost for static calls.\nThis can also be fixed by not allowing dynamically-sized local variables with an alignment more than some maximum value and having all dynamically-sized locals use that maximum alignment unless optimizations can prove that a smaller alignment suffices.\nMessing with the ABI wouldn't help with unsized locals in general (assuming is correct), since e.g. will also need an alloca with dynamic alignment in general. Given only a value, there is no static way to say anything about its alignment, so how would you distinguish whether calling a method on it is OK?\nCan we call and then align the pointer for the local ourselves as a workaround until we come up with a good solution?\nIn clang there's a function which might or might not be useful in this case.\nrequires a constant alignment. Non constant alignments are . This matches semantics of LLVM instruction, so it's not helping, as alignment of value in is unknown at compile time when moving from .\nI think that overallocating for unsized locals of unknown alignment may make sense. You can and then make use of to compute the offset. Sure, it increases stack requirements, but it seems acceptable for , and in most cases you end up with extra 7 bytes on stack or less. 256 alignment seems like an edge case where wasting 255 bytes doesn't matter."}
{"_id":"doc-en-rust-35b067be423839cfae33dfa0b48475783f27ab1ed0904fd969f99c950d943054","title":"","text":"if we keep setting as the default alignment we can skip the overallocating and offset dance for types with an alignment below that.\nMy idea was that rustc would prohibit coercing overaligned types to a dyn trait that takes by value. So:\nThe alignment is dynamically determined though, not sure if saving 15 bytes of stack space is worth the conditional branch?\nOh right. Yea that's probably not helpful.\nSince , this would be backwards incompatible (at latest) once trait object upcasting is finally implemented: and trait objects would have to have the same alignment restriction (because you can upcast to ), but today you can freely create such objects with any alignment.\nI was under the impression that calling didn't require dynamic , is that related to missing MIR optimizations, meaning we have unnecessary moves which end up duplicating the data on the stack using a dynamic ?\nCorrectness shouldn't rely on optimizations to fire...\nSure, I was just hoping we weren't relying on \"unsized locals\", only unsized parameters (i.e. ), for what we're exposing as stable. And I was hoping an optimization wouldn't need to be involved to get there. I wonder if it would even be possible to restrict \"unsized locals\" to the subset where we can handle it entirely through ABI, and not actually have dynamic s anywhere, since that would make me far more comfortable with 's implementation or even stabilization. Ironically, if that works, it's also the subset we could've implemented years earlier than we did, since most of the complexity, unknowns (and apparently bugs) are around dynamic s, not calling trait object methods on a dereference of .\nThat should be possible. I think everything that is necessary is performing the deref of the box as argument () instead of moving the box contents to a local first () That would also make it possible to call in cg_clif. Cranelift doesn't have alloca support, so the current MIR is untranslatable.\nHmm, but that's not trivially sound because it could lead to MIR calls where argument and return places overlap, which is UB. We'd potentially have to special-case it to derefs, but even then what's to stop someone from doing ? Maybe we could introduce a temporary for the return value instead, for these kinds of virtual calls? That should remove any potential overlap while allowing the call."}
{"_id":"doc-en-rust-e0557b2e15a4d389c0583e27ec38e510a3d214eb85386293065b15f95dc546f5","title":"","text":"(Unrelatedly, I just realize we use a copying-out shim for vtable entries that take by value, even when would be passed as at the call ABI level. We would probably have to make computing the call ABI a query for this microopt to not be expensive)\nThat would result in being moved to a temp first before dropping and calling the boxed closure. If it wasn't moved first before the drop of , then borrowck would give an error. (I meant for this change to be done at mir construction level, not as an optimization pass, so borrowck should catch any soundness issues)\nWe can try it, I guess, but right now a lot relies on many redundant copies/moves being created by MIR building and may not catch edge cases like this. But also I don't think moving out of a moves the itself today. Me too, but I was going with the \"correct by construction\" approach of creating a redundant copy/move, just on the return side, instead of the argument side, of the call.\nAfter revisiting on triage, removing nomination.\npre-triage: nominated for discussion in the next weekly meeting.\nI just checked and, a function call roughly this (touched up for clarity): Some of my previous comments assumed the wasn't there and the call would use the destination directly, but given that there is a move, that simplifies my suggestion. <hr/For virtual by-value calls, we can skip one move when building the MIR, specifically the move out of the dereference of a for the argument. Given that we already move the result of the call, there should be no aliasing caused by this, but if we decide to change anything about how we build MIR calls, we'd need to be extra careful. We can also make this pattern be gated by a separate feature-gate (rather than ), and make sure the standard library only uses that feature-gate and not . This should solve any alignment issues might have, because we'd not be using dynamic unless the broader feature is used.\nOK, if I understand what's being proposed here, it is to excerpt a subset of the \"original unsized-locals plan\" -- specifically, to permit locals with unsized types, but only in contexts where we can be guaranteed that we can point to the original storage and don't actually have to move any value (and hence we don't require variable size stack frames)."}
{"_id":"doc-en-rust-5beba8d62abc39b05f6e650dcce3335b6738bd1d349d26aea50dceae17630e1f","title":"","text":"I'm in favor of this proposal, but I do think we want to be slightly careful to ensure we're not violating soundness. The main concern would be if there is some way to access or re-use the variable that was moved. I attempted to do so with this example () but it fails to compile: The error here arises because the closure would need to capture a to do anything, which prevents a later move. But maybe there is some kind of tricky example that can arise where we re-assign the value during argument evaluation?\ncompiles and does before , where is the result of .\nBorrowck should prevent that, right?\nborrowck may rely on MIR building creating extraneous copies, so we can't just assume it helps us. IMO we should limit it to functions taking unsized parameters and function calls passing such parameters or dereferences of es (any other pointer/reference doesn't support moving out of).\nWell, I think is right that borrowck would catch violations of soundness in some strict sense, but I guess what I meant is that we might be breaking backwards compatibility.\nThe example that feels pretty relevant. If I understood your proposal, it would no longer compile. If I recall (thinking back), I had a plan to handle this by save the to an alternate location in the actual call, we pass ownership of and then do a shallow free of the This still seems like it would work, though I'm not sure how easy/elegant it is to formulate. In a sense we'd be rewriting to .\nIsn't example dependent on doing a direct virtual call? My understanding is that you can't do this on stable with because the virtual call exists in one place, in libstd, and it doesn't do anything weird, so it would work with a restricted ruleset. EDIT: if it can work on stable, it's because calling 's will move the whole before the assignment is evaluated, which is fine, because the shallow drop is actually inside that , not its caller.\nI agree that this code doesn't compile on stable today, but I'm not sure if that's the point. I guess you're saying it's ok for it to stop compiling? I think what I would like is that our overall behavior is as consistent as possible between Sized and Unsized parameters. I think we could actually do a more general change that doesn't special case Sized vs Unsized or anything else."}
{"_id":"doc-en-rust-c0a55b5a9c88bb1e08f508b1fb679a6cf9e068e808080659d5f7ae2be7470592","title":"","text":"I think I am basically proposing the same thing as earlier, but with a twist: Today, when building the parameters, we introduce a temporary for each parameter. So if we had we might do: What I am saying is that we could say: If the argument is moved (not copied), and the \"place\" has outer derefs (e.g., we are passing where is some place), then we assign the place to a temporary and we make the argument to the function be : I don't believe this is observable to end-users, except potentially for when the destructor on runs. I believe that it accepts all the same code we used to accept. It also has nothing specific to or types at all. Does that make sense? I'm very curious to know if anyone sees any problems with it. (One obvious thing: if we ever add , its design would have to accommodate this requirement, but I think that's fine, in fact the complications around getting moves right for precisely this case are one of the reasons we've held off on thus far.)\nCan you not reinitialize today? If you move the whole , it is indeed more conservative (and should let us skip unnecessary moves even in cases). But also, do you want to move the locals check from typeck to borrowck? I don't have an intuition for when your approach wouldn't create unsized MIR locals, from the perspective of typeck. However, this is only relevant if we want a stricter feature-gate. At the very least it seems like it would be easier to implement a change only to MIR building, and it should fix problems with for the time being, even without a separate feature-gate.\nHmm, that's a good point, I think do that. Sigh. I knew that seemed too easy. I remember we used to try and prevent that, but we never did it fully, and in the move to NLL we loosened those rules back up, so this compiles: Still, you could do my proposal for unsized types, though it would introduce an incongruity. UPDATE: Oh, wait, I remember now. For unsized types, reinitialization is not possible, because you can't do with an unsized rvalue (we wouldn't know how many bytes to move). So in fact there isn't really the same incongruity."}
{"_id":"doc-en-rust-8eda5e2da06426c5ca0d1e41f6002aa4939e49c4190b6fbed85bbea5acf8da8e","title":"","text":"To be clear, I wasn't proposing changing anything apart from MIR building either, I don't think. IIUC, what you proposed is that would be compiled to: whereas under my proposal (limited to apply to unsized parameters, instead of moved parameters) would yield: I think I mis-stated the problem earlier. It's not so much that your proposal will introduce compilation errors, it's that I think it changes the semantics of code like this in what I see as a surprising way: I believe that this code would compile to the following under your proposal: which means that would be invoked with the new value of , right? Under my proposal, the code would still compile, but it would behave in what I see as the expected fashion. Specifically, it would generate:\nIsn't there a way to \"lock\" that value through the borrow-checker, so further accesses would be disallowed, until the call returns? I'd rather be stricter here. <hr/My point was that if your proposal affects sized moves, you're breaking stable reinitialization. If it doesn't affect sized moves, I don't see how this applies anymore:\nLet me just chime in here and say that this is a pain in Miri. Unsized locals are pretty different from sized locals, I had to introduce a bunch of special hacks to make them work. MIR locals even needed a new state just for them: Lazily allocating locals seems odd to me, but at least we can consistently do that for all locals. Elsewhere however to make this lazy initialization actually work out and catch mistakes where an unsized local is \"overwritten\" with a value of different size: This all feels really unprincipled, and it would be great if at some point we could come up with a coherent semantics for unsized locals in MIR. The worst part is that the size of a local is implicitly determined on the first write to it. It would be much better to be explicit about that, e.g. at time.\nI don't think we have anything like this today, but presumably we could add such a thing, but I'm not quite sure what you have in mind. When does this prohibition on further accesses take effect?"}
{"_id":"doc-en-rust-27fd42f01a24ee7bd4fa9f1c0f7bf282c5af37d103c7e5a053a6ed0f28b8ecdb","title":"","text":"In particular, the IR for under your proposal, if I understood, would be But the access to that (I believe) we wish to prevent takes place in the \"evaluate remaining arguments\" part of things. So I think we'd have to add some sort of \"pseudo-move\" that tells borrowck that should not be assignable from that point forward, right? Well, it depends on your perspective. It's true that, given the need to permit reinitialization, the check is now specific to unsized values -- i.e., MIR construction will be different depending on whether we know the type to be sized or not. That's unfortunate. However, I think we still maintain a degree of congruence, from an end-user perspective. In particular, users could not have reinitialized a anyhow. However, under my proposal, users can write things like and the code works as expected (versus either having an unexpected result or getting an error). In any case, it seems like we're sort of \"narrowing in\" on a proposal here: when we see a function call with a parameter that is , and the value being passed is a deref, we want to modify the IR to not introduce a temporary and instead pass that parameter directly from its location, either we do some sort of \"no more assignments\" lock, or we move the pointer and introduce a temporary (and then pass in a deref of that temporary) Does that sound right so far?\nIf it's easier to do the more flexible approach (by moving the pointer) than the \"locking\" approach (which is a bit like borrowing the pointer until all arguments are evaluated, then releasing the borrow and doing a move instead), I don't mind it, I was only arguing with the \"uniformity\" aspect. Something important here: your approach is stabilizable, while mine is meant more for that one in the standard library, and not much else.\nYes, I was kind of shooting for something that we could conceivably stabilize.\nRemoving nomination, this was already discussed in triage meeting and it's under control.\nSo should we maybe try out the approach I proposed and see how well it works?\nyes, going to try that out.\nFor the record, the \"new plan\" is this."}
{"_id":"doc-en-rust-7cf635da4f5adcfae533b40271ecf10f20aa01733028a100f12d429f49c1ae0c","title":"","text":"When generating the arguments to a call, we ordinarily will make a temporary containing the value of each argument: But we will modify this such that, for arguments that meet the following conditions: The argument is moved (not copied), and its type is not known to be , and the \"place\" has outer derefs (e.g., we are passing P where P is some place), then we assign the place P (instead of ) to a temporary and we make the argument to the function be (instead of ). This means that given where , we used to generate but now we generate We are now moving the box itself, which is slightly different than the semantics for values known to be sized. In particular, it does not permit of the box after having moved its contents. But that is not supported for unsized types anyway. The change does permit modifications to the callee during argument evaluation and they will work in an analogous way to how they would work with sized values. So given something like: we will find that we (a) save the old value of to a temporary and then (b) overwrite while evaluating the arguments and then (c) invoke the with the old value of .\nUpdate: There is also\nis a perfectly normal operand, I don't know what you mean. It's the same kind of as we currently have in (on the RHS)\nOh sorry, somehow I thought operands could only refer directly to locals, not also dereference them. I think I am beginning to see the pieces here -- together with function argument handling, this entirely avoids having to dynamically determine the size of a local. I have to agree that is quite elegant, even though baking \"pass-by-reference\" into MIR semantics still seems like a heavy hammer to me. On the other hand this places a severe restriction on now unsized locals may be used, basically taking back large parts of Is there some long-term plan to bring that back (probably requires with dynamic alignment in LLVM)? Or should we amend the RFC or at least the tracking issue with the extra restrictions?\nI would keep the more general feature but use two different feature-gates (if we can). And just like with a few other feature-gates () we could warn that (the general one) is incomplete and could lead to misaligned variables (or something along those lines)."}
{"_id":"doc-en-rust-e815c1522a134b198016730d0062b3d332c75119cceb0b89e314acd16ab4a8f8","title":"","text":"We could also add runtime asserts that the (dynamic) alignment is respected, once we know could never trigger them (e.g. from stable code).\nI was wondering about that too. It seems like it'd be good to review the more general feature in any case. This is partly why I brought up the idea of wanting a guaranteed \"no alloca\" path -- this was something I remember us discussing long ago, and so in some sense I feel like the work we're doing here isn't just working around LLVM's lack of dynamic alignment support (though it is doing that, too) but also working to complete the feature as originally envisioned.\nI two notes to the tracking issue so we don't overlook this in the future.\nThis is probably expected, but the fix failed to actually make sound:"}
{"_id":"doc-en-rust-7811b7a2f303a5f58ef82ba35ee8a1f711e600ae55df46a78f211271e11340f9","title":"","text":"The feature gate for the issue is . Tracking issues are used to record the overall progress of implementation. They are also uses 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. [ ] Adjust documentation ([see instructions on rustc-dev-guide][doc-guide]) [ ] Stabilization PR ([see instructions on rustc-dev-guide][stabilization-guide]) [stabilization-guide]: https://rustc-dev- [doc-guide]: https://rustc-dev- Initial implementation ()\nFWIW, here is a full-featured API provided by an external crate:\nI wonder how this API relates to . It would be great if there was some safe API that wrapped around the use of to access a 's spare capacity, then updated based on the s .\nMaybe we should follow that example and generalize to return ?\nhas implemented that, albeit as a private function. Sounds like a good idea to me.\nSince exists now I think is redundant.\nThat's not actually true due to pointer invalidation, see and\nI think it would be better to have this feature sooner rather than later. I'm starting to notice instances where people are doing things that are probably or definitely UB because they want this functionality. So I think this API falls squarely into the standard library's mission to provide pre-built and correct implementations of things that are subtle or difficult to get right.   (originally posted on but per Ralf's comments there, it is probably better to have this method for the above use cases)\nI agree. I've been using this in my code and found it to be very useful. Even though is more general, I've never had a need for it and I feel that is useful on its own. The API being stabilized is: 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!"}
{"_id":"doc-en-rust-742906eebb5dad82554213ea7a1a5673a2db700b48e8e965505025d542167197","title":"","text":"See for info about what commands tagged team members can give me.\nwhile waiting for this feature to be stabilized, you should suggest that and use one of the convenience methods in:\n:bell: This is now entering its final comment period, as per the . :bell:\nRalf mentioned this on , mostly rewording with my own opinion: I would prefer not to recommend that function, because even if you just want access to the spare region, under SB, these interfaces invalidate all pointers to the initialized region. I think that's too much of a footgun for codebases where people are already writing code that is rejected by Miri.\nI wonder how many people do keep outstanding pointers to the initialized part while toying with the extra part 's implementation is already better than their 0-elems slices that get -ly converted into non-empty slices (and currently better than the stdlib one since it doesn't involve a 12-week delay for stable Rust). Anyhow, I've just released a new version () with a dedicated adapter: , for extra good measure.\nTo be clear, my concern is that the splitting interfaces are adding a landmine for the future. If I'm sending someone a PR I'll make sure it passes Miri at the time, but that's a hard condition to maintain. Especially because the two aforementioned codebases have dependencies that do int-ptr casts, an operation that Miri just doesn't understand at the moment, so it would be hard to advocate Miri in CI.\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-61432f56219da73b3d8b56806dcc1faf500f0340871ae45fa63f399bd89a3fb3","title":"","text":"I tried to document this code: I expected to see this happen: charstd::char` points to module page of char type points to char primitive page Instead, this happened: type points to module page of char :\nI think the problem is that modules are in the type namespace, so is doing exactly what you are asking it for (the module, since it has higher priority). Since the built-in types scope is the lowest precedence, perhaps there needs to be a way to access it directly? Maybe something like or ? Or maybe should skip over modules, and keep looking deeper in the scope hierarchy? (cc )\nOh hmm I see what you mean. There are : Types, values, and macros. Since modules and types are in the same namespace, it uses the first one it finds. Maybe we could work around this by first resolving in an empty module (so it has nothing in scope), then only falling back to the current scope if we don't find something there?\nI'm surprised this hasn't caused trouble before now. Does the root of never use the primitive?\nI don't know how it works, but the resolver is smart enough to know that in a type context won't match a module (like , the won't match a module named \"char\". Maybe it has something to do with late-resolution  which has a to give it some context?\nAdding that would be more of area ... I can give it a shot though.\nIt looks like doesn't even return a resolution and only records it for later use ... I'm going to go with the empty module workaround and we can fix it later if it turns out to cause issues.\nThe double resolve seems hacky. We could probably make type@ specifically not resolve to a module, perhaps? Also, note that modules are in all namespaces\nHow would that work? We could skip any module resolutions, but since modules have precedence over types I don't know how we'd get the primitive type to resolve afterwards.\nOh hold on we have a function already. We can look at directly.\nThis doesn't have anything to do with primitives, this has to do with glob imports vs non-glob imports. You can get the same issue with the following:\nThis also doesn't have to do with modules being \"resolved first\" or anything. Things that are non-glob in-scope are resolved first."}
{"_id":"doc-en-rust-1bad049a447735444f3ad60bbaefb3440c9d43c0a1ae5f6aabc0f7f34e628fe7","title":"","text":"Actually, my bad: This does have to do with primitives in the sense that primitives are the only thing that still work when shadowed because of some special code in checking the primitive tables. I think when the string matches one of the primitive table entries for TypeNS lookups that were explicitly annotated with type@ and resolve to a module we can hack this in. In the future we might want to tighten up this code so that e.g. can't resolve to an enum, etc.\ndo you mind if I fix at the same time and resolve primitives even before modules? That seems like the less surprising behavior to me, the module can still be disambiguated with .\nI'm a bit wary of doing this because having the char module in scope is not a common situation, and it will get weirder for people who have a different char module. I think we should resolve to whatever is in scope, but if is explicitly mentioned we can then force resolve to the primitive."}
{"_id":"doc-en-rust-c4a5273a933e8a31db83bc0532f1121df06f4a5ea514257a527d1d7d6a098f8b","title":"","text":"https://crater-\nI'll need to re-check later but this seems to bisect to somehow.\nThe UI test changes from that PR appear to back this up, as confusing as it is.\nI'm not sure what's going on in that crate, if it built successfully by mistake, or how that PR interacts with it, so let's cc the PR author and reviewer for validation.\nAfter , no longer implements and , because the context now contains a which doesn't implement those traits. So this is an issue with the standard library and not the crate being built. Repro: label -T-compiler +T-libs +S-has-mcve\nWG-prioritization assigning priority (). Noticing this on which says that was meant to be confined on nightly. Unsure about the fallout of this regression but for now marking as critical for tracking purposes. label -I-prioritize +P-critical\nRevert up:\nIsn't not unwind safe?\nThat line was by your PR, so while what you say is technically true, talking about what \"already happened\" when we are traveling back and forth through time via version control may be more confusing than helpful.\nThat line was already there. I the line below it though. Original PR:\nApologies, I guess I can't count numbers today? Hm, so, the full error of the regression is this: Note that it's trying to make a pointer implement . And for what it's worth, stable does indeed document is . Thus unfortunately that line you pointed to, as opposed to the one I thought you were referring to, is effectively just documenting that all are , and that will include regardless of whether it is is . And confusingly, , unlike .\nI have opened as an alternative."}
{"_id":"doc-en-rust-e14d33ba39600496f5ab1dfe09731cf4421241a31efd1d602d84ce27824d49eb","title":"","text":"The following code () panics the compiler in stable 1.38.0, beta 1.39.0-beta.6, and nightly 2019-10-17: Removing the bound or filling it with makes it compile just fine. Error + backtrace:\ncc\nHmm, I didn't know that adding a \"syntactically trivial bound\" could cause something like this. Is there some implicit bound that gets in cases like this?\nminimized test case ():\nThe minimized test worked in previous stable Rust versions (at least in 1.33 under 2015 edition; though 2018 edition breaks there, which indicates this is with 99.999% certainty injected by MIR-borrowck...)\ntriage: P-high. Adding self to assignee list; removing I-nominated."}
{"_id":"doc-en-rust-0c01f8b386510b5a6fbed027ba17dadb6ac102acc71a2f78f7915ba6b4a839d2","title":"","text":"The following snippet works fine before but now it reports a warning: Steps to reproduce: clone rustup override set nightly-2017-08-11 cargo test Is this an expected behavior, or a bug? Thank you!\ncc -- probably related to the new lint implementation\nYes this was caused by The bug is on . The check for whether is in scope is not checking the current set of attributes being linted. For example this does not warn: but this warns: (as you've noticed) The fix is to just take the local variable into account which has the up-to-that-point set of lint attributes collected.\nI've opened a PR for this at"}
{"_id":"doc-en-rust-7accc4af3c6adb97fe69cbac3ba58b19914fb38653e6ecbb38372fc5512eb31d","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: same codegen or similar in performance Instead, this happened: array has way worse codegen <details<summaryAssembly</summary<p</p</details<!-- Provide the most recent version this worked on, for example: It most recently worked on: Rust 1.47 --It most recently worked on: 1.64 <!-- Provide the version you are using that has the regression. --65 till now. Regressed in nightly-2022-08-13, maybe LLVM 15 ?: : <!-- Did the compiler crash? If so, please provide a backtrace. --<!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details<!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. -- modify labels: +regression-from-stable-to-stable -regression-untriaged <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nWG-prioritization assigning priority (). cc since this regressed in the LLVM 15 update label -I-prioritize +P-medium +T-compiler\nI've seen llvm doing these strange 1-byte-at-a-time \"vectorizations\" in other places too. This might be a more general problem. In this case we can probably paper over it by implementing TrustedRandomAccess for the array iter.\nUnfortunately, the array iterator is fundamentally worse right now, because indexing into it -- a fundamental part of being a by-value array iterator -- keeps it from SRoAing and thus doesn't optimize well. This is why when I was making better I ended up making to not have to use . Sadly, for the foreseeable future you're better off using the \"weaker\" slice iterator when you can.\nMy guess is that the SROA is missing something in the opaque pointer mode."}
{"_id":"doc-en-rust-12c456fcdc7585c898a09e85a8177c665385f1e385350274a9409c5abef187fb","title":"","text":"claim\nIt's not about vectorization. This optimization can be restored by using . But highly unrecommended. Upstream issue:\nThe upstream issue is closed. claim"}
{"_id":"doc-en-rust-d9788f9fb62c8de2f97f07962af96a35636fdc8a876f620741389e1c3bb30856","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '-Zunstable-options --edition=2024 -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error: impossible case reached', 'error: internal compiler error: impossible case reached' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [coroutinebymovebodydefid] looking up the coroutine by-move body for [analysis] running analysis passes on this crate -- label +F-asyncclosure\nAs a step of reducing your code examples, could you please ensure that is necessary to reproduce this ICE before mentioning it in the issue? This ICE reproduces on edition 2021, which is the current stable edition.\nMy project fails on nightly also while using edition 2021.\nYep, a fix is already up and it's waiting for approval. I recommend downgrading to a slightly older nightly until this is fixed."}
{"_id":"doc-en-rust-a71721f88961ea6b81b7ebd2effb1c60287400743a9f36a25fc65e8df7e54b5f","title":"","text":"we currently output The suggestion is incomplete and will not result in compilable code. Because the lifetime is coming from an argument of type , which is an unconstrained type parameter, itself will not have the needed lifetime and causes the obligation that we're trying to reverse by suggesting . The appropriate changes to the code would be either or , depending on whether appears in any other argument or not.\nThe suggested code ."}
{"_id":"doc-en-rust-eac71975284c29468d15101371d7dec17505b09a4c2a386257a23b255df72ff3","title":"","text":"I'm opening this up to serve as a tracking issue for enabling multiple codegen units in release mode by default. I've written up a before but the tl;dr; is that multiple codegen units enables us to run optimization/code generation in parallel, making use of all available computing resources often speeding up compilations by more than 2x. Historically this has not been done due to claims of a loss in performance, but the is intended to assuage such concerns. The most viable route forward seems to be to enable multiple CGUs and ThinLTO at the same time in release mode. Blocking issues: [x] Enable for libstd on all platforms - - - - Potential blockers/bugs: - -\ncc\nPresumably this will remain a stable compiler flag, but what else will change by default? Is the plan to make this only affect , or is the plan to also make this affect ? Do we want to make continue to use only a single CGU, to hedge against regressions for people who are already willing to trade off compiler time for runtime?\nI would specifically propose that any opt level greater than 1 uses 16 codegen units and ThinLTO enabled by default for those 16 codegen units.\nThis is very interesting. One would think that ThinLTO-driven inlining should always have to do less work when our much more conservative pre-LLVM inlining. But that doesn't always seem to be the case, as in the . Most tests on the seem to profit though. Overall it's still not a clear picture to me.\nwas that comment meant for a different thread? I forget which one as well though, so I'll respond here! As a \"quick benchmark\" I compiled the regex test suite with 16 CGUs + ThinLTO and then toggled inlining in all CGUs on/off. Surprisingly inlining in all CGUs was 5s faster to compile, and additionally . In those timings is where inlining is only in one CGU, where is inlining in all CGUs. One benchmark, , got twice as slow!\nYeah, the comment was in response to (rust-doom) but since that was closed already, I put it here."}
{"_id":"doc-en-rust-8459400afb569ad2188b3cd5b231230badf367bcfeb89dca33d60d66624907a0","title":"","text":"Regarding the compilation time difference between pre- and post-trans inlining, my hypothesis would be that sometimes pre-trans inlining will lead to more code being eliminated early on (as in the case of regex apparently) and sometimes it will have the opposite effect. I suspect that there's room for improvement by tuning which LLVM passes we run specifically for ThinLTO. Or do we do that already?\nHeh it's true yeah, I'd imagine that there's always room for improvement in pass tuning in Rust :). Right now we perform (afaik) 0 customization of any pass manager in LLVM. All of the normal optimization passes, LTO optimization passes, and ThinLTO optimization passes are all the same as what's in LLVM itself.\nI wanted to also take the time and tabulate all the results from the to make sure it's all visibile in one place. Note that all the timings below are comparing a release build to a release build with 16 CGUs and ThinLTO enabled Improvements All of the following compile times improved, sorted by most improved to least improved Regressions The following crates regressed in compile times, sorted from smallest regression to largest alexcrichton's attempt to reproduce the regressions Here I attempt to reproduce the regressions on my own machine with Unfortunately the only regression I was able to reproduce was the rust-belt regression. I'll be looking more into that.\nLooking into , one interesting thing I've found is that the crate takes longer to compile with ThinLTO than it would otherwise. Looking at it appears that one codegen unit in this crate takes 99% of the time in LLVM. This codegen unit appears to be basically entirely dominated by . Almost all of the benefit of multiple codegen units is spreading out the work across all CPUs. Enabling ThinLTO to avoid losing any perf is fundamentally doing more work than what's already happening at , but we get speedups across the board in most cases. If we have one huge CGU, split it in two, and work on those in parallel then we've got 50% of the original time to run ThinLTO (in a perfect world). If ThinLTO takes more than 50% of the time then we'd have a build time regression, but that's almost never happening."}
{"_id":"doc-en-rust-826aee41cb0e8b13d2368b8675cf3e3aa442a17b3bcb7408e02c50b17283eed2","title":"","text":"What's happening here is that we have one huge CGU, but when we split it up we still have one huge CGU. This means that the CGU which may take ~1% less time in LLVM only gives us a tiny sliver of a window to run ThinLTO passes. In the case of the crate this means that adding ThinLTO passes is an overall build time regression. So generalizing even further, I think that enabling ThinLTO and multiple CGUs by default is going to regress compile time performance in any crate where our paritioning implementation doesn't actually partition very well. In the case of we've got one huge function which hogs almost all the optimization time (I think) and the entire crate is basically dominated by that one function. I would be willing to conclude, however, that such a situation is likely quite rare. Almost all other crates in the ecosystem will benefit from the partitioning which should basically evenly split up a crate. maybe you have thoughts on this though?\nThank you so much for collecting and analyzing such a large amount of data, Your conclusions make sense to me. Unevenly distributed CGU sizes are also a problem for incremental compilation; e.g. the test sees 90% CGU re-use, yet compile time is almost the same as from-scratch. In the non-incremental case it might be an option to detect the problematic case right after partitioning and then switch to non-LTO mode? I'm not sure it's worth the extra complexity though. For cases where there is one big CGU but that CGU contains multiple functions, we should be able to rather easily redistribute functions to other CGUs. We'd only need a metric for the size of a . The number of MIR instructions might be a sufficient heuristic here. That would not help for but it might help for other crates. In conclusion, judging from the table above, I think we should make the default sooner rather than later. Open questions I see: What to do about ? I would have thought that it would always be a clear win to disable this when ThinLTO is enabled but that doesn't seem to be the case. Are there hardware configurations where this never is a win? E.g. should we default to traditional compilation if ?"}
{"_id":"doc-en-rust-a39618a6d2ec0fbbc39b9a1ecc2ba00b73839dc85487f888bb218f3688a727ce","title":"","text":"FWIW, as the author of , which is a made-for-fun Piston game, I am more than happy to take a small compile regression when it seems like vast majority of crates get huge real-time improvements!\nThis seems like a good thing to have in our back pocket, but I'm also wary of trying to do this by default. For example the case is one where we may wish to disable ThinLTO but the one massive function could also critically rely on a function in a different CGU being inlined? That sort of case would be difficult for us to determine... In any case though I agree that we probably don't need the complexity just yet so I think we can defer this for later. Agreed! So far all the crate's I've seen the O(instructions) has been quite a good metric for \"how long this takes in all LLVM-related passes\", so counting MIR sounds reasonable to me as well. Again though I also feel like this is ok to have in our back pocket. I'd want dig more into the minor change example, I'm curious how awry the CGU distribution is there and whether a heuristic like this would help. Quite surprisingly I've yet to see any data that it's beneficial to compile time in release mode or doesn't hurt runtime. (all data is that it hurts both compile time and runtime performance!) That being said we're seeing such big wins from ThinLTO on big projects today that we can probably just save this as a possible optimization for the future. On the topic of inline functions I recently dug up again (later closed in favor of , but the latter may no longer be true today). I suspect that may \"fix\" quite a bit of the compile time issue here without coming at a loss of performance? In any case possibly lots of interesting things we could do there. Also a good question! I find this to be a difficult one, however, because the CGU number will affect the output artifact, which means that if we do this sort of probing it'll be beneficial for performance but come at the cost of more difficult deterministic builds. You'd have to specify the CGUs manually or build on the same-ish hardware to get a deterministic build I think? I think though that if you have 1 CPU then this is universaly a huge regression."}
{"_id":"doc-en-rust-4426806565390046acd7ad33b00b13788407fc81b51697f17774c126464fdbb6","title":"","text":"With one CPU we'd split the preexisting one huge CGU into N different ones, probably take roughly the same amount of time to opimize those, and then tack on ThinLTO and more optimization passes. My guess is that with one CPU we'd easily see 50% regressions. With 2+ CPUs however I'd probably expect to see benefits to compile time. Anything giving us twice the resources to churn the cgus more quickly should quickly start seeing wins in theory I think. For now though the deterministic builds wins me over in terms of leaving this as-is for all hardware configurations. That and I doubt anyone's compiling Rust on single-core machines nowadays!\nOne thing I think that's also worth pointing out is that up to this point we've mostly been measuring the runtime of an entire . That's actually, I believe, the absolute worst case scenario for where ThinLTO will provide benefit. Despite this, it's showing huge improvements for lots of projects! The benefit of ThinLTO and multiple CGUs is leveraging otherwise idle parallelism on the build machine. It's overall increasing the amount of work the compiler does. For a from scratch, though, you typically already have tons of crates compiling for the first half of the build in parallel. In that sense there's not actually any idle parallelism. Put another way, ThinLTO and multiple CGUs should only be beneficial for builds which dont have many crates compiling in parallel for long parts of the build. If a build is 100% parallel for the entire time then ThinLTO will likely regress compile time performance. Now you might realize, however, that one very common case where you're only building one crate is in an incremental build! Typically if you do an incremental build you're only building a handful of crates, often serially. In that sense I think that there's some massive wins of ThinLTO + multiple CGUs in incremental builds rather than entire crate builds. Although improving both is of course great as well :)\nFor deterministic builds you have to do some extra configuration anyway (e.g. path remapping) so I would not consider that a blocker. And I guess there are single core VMs around somewhere."}
{"_id":"doc-en-rust-9cbbd7c4c8d3f7f4c75a168140fc39d1686ff5f6d6e1524b514ba1c75b0b91ac","title":"","text":"But all of this is such a niche case that I don't really care MIR-only RLIBs should put us into a pretty good spot regarding this, so I'm quite confident that we're on the right path overall.\nThat's really interesting. For incremental compilation enabled the situation might be different (because pre-trans inlining hurts re-use) but for the non-incremental case it sounds like it's pretty clear what to do.\nYeah, maybe we should revisit this at some point. Although I have to say the current solution of only and symbols and nothing in between is really nice and simple.\nHm yeah that's a good point about needing configuration anyway for deterministic builds. It now seems like a more plausible route to take! Also that's a very interesting apoint about incremental and inlining on our own end... Maybe we should dig more into those ThinLTO runtime regressions at some point! Also yeah I don't really want to change how we trans inline functions just yet, I do like the simplicity too :)\nout of curiosity how did you figure out this and which function it was. I've wanted to look into why the webrender build is so slow and would welcome tips.\noh sure I'd love to explain! So I originally found as a problematic crate when compiling rust-belt as it just took awhile and I decided to dig deeper. I checked out the crate and ran: That drops in the current directory, and opening that up I see: ! The graph here isn't always the easiest to read, but we've clearly got two huge bars, both of which correspond to taking a huge amount of time for that one CGU (first is optimization, second is ThinLTO + codegen). Next I ran: and that command dumps a bunch of IR files into . Our interesting CGU is so I opened up (we sure do love our long filenames). Inside that file it was 70k lines and some poking around showed that one function was 66k lines of IR. I sort of forget now how at this point I went from that IR to determining there was a huge function in there though...\nI don't know if this is the right place, but I think it should be considered whether the symbol issues reported in the Nightly section here: should be considered a blocker or not."}
{"_id":"doc-en-rust-b0225b6de619b46503f20143d72f83ac92cc3a4f9288ee033156ed5537d68271","title":"","text":"The tl;dr is that certain versions of llvm, (i've seen this on 3.8, and whatever llvm rustc nightly uses) appends seemingly random garbage to the end of some names, e.g. we get: instead of: This knocks the debuginfo out of sync (it doesn't have the garbage appended). I've been able to repro this with clang3.8 for c++ files as well (haven't tested on other llvm), and switching to 5.0 seems to have fixed the issue. I don't know if its within reach, but perhaps we should attempt upgrading to llvm 5.0 before releasing this on stable? Note I understand this is for release mode, but i see this in debug mode on rustc nightly right now as well..."}
{"_id":"doc-en-rust-0e86f5cad76845a9579f9f9606cb740329e6e79be0820e577c6d84ca9b39e498","title":"","text":"An there actually does panic for the test. I only moved this code between the files, the same comment and code pattern exists as well for normal closures: Originally posted by in\nI couldn't repro this failure, maybe was doing instead of ? The ordering is important here.\nI believe I did, yes."}
{"_id":"doc-en-rust-9d3c81fe33119973c08c87410d7d37fcbfdb78fb83e02fe3f92be033b67d8c9f","title":"","text":"If you try to compile the crate with , it fails with the following error: This seems to be a regression from to , and my best guess for the change that caused it is this pull request: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nFiled to fix this. FYI, a short-term workaround is to enable the target feature (). claim\nPossibly related: This is seen cross-compiling from Linux to Windows. Giant 1MB linker error message related to atomicload, only in release mode, for target x8664-pc-windows-gnu. Failing in rustc 1.67.1 stable. Currently asking for help comments; will file an issue in a day or two if nobody reports a known fix.\nSince native atomic ops exist in x86_64, I don't believe this and are related to your problem. Given that rend3 has enabled , your problem may be related to"}
{"_id":"doc-en-rust-4d9b54406be2b0d5d10f059f2c67e8041015d0a68b78c29f2103bd87faca341b","title":"","text":"While checking whether the can be ported from typenum to nightly with , I hit this warning. I am not sure whether it's a false positive or whether the behavior I want is meant to be disallowed, but I think it should be allowed when enabling . I've reduced the code though I left some stuff to show why it would be useful. Originally posted by in\nis emitted if we successfully evaluate an anonymous constant with generic const arguments. Anonymous constants currently inherit all of their parents generics, so for the constant has both and in scope, even though it only uses . This would mean that pretty much all anonymous constants would cause that lint, so we add a flag to their MIR to detect whether they actually use any generic parameter: uses so that flag is true. The problem is now that is concrete, so evaluating the constant is successful, but the constant refers to which is still generic. We should just disable the lint if is enabled :shrug: cc\nAnother similar. Short example failing on Nightly (thanks to ilyvion for narrowing it down): My use case: I know it's a semantic/voluntary constraint only, and it's quite recursive, but I believe it deserves its place. (Alternatives I tried are at )\nthis has been fixed, needs test to close"}
{"_id":"doc-en-rust-b7f768d026fd619aa42b9313b030c74199b4765c38e4a28a27ff8e7b4969af5e","title":"","text":"I was sent here from the . Please advise if I am posting in the wrong area. format! macro documentation could be improved by changing one of the examples to be more obvious to new users. Change the example to Additionally, assert! could be used to demonstrate final string values: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nSomething like ? claim\nI think the use of \"val\" certainly makes it more obvious than my suggestion to use \"z\". Your suggestion would also do it in one line... I guess the question is whether you would prefer to make it more obvious (readable) by splitting it into two lines. This is my first contribution to Rust in any form, so I'm happy to go with your suggestion.\nThanks all!"}
{"_id":"doc-en-rust-eee16135a025f8d535aa50a43458bc0bd1248f8d4ff621d911164f71beff127d","title":"","text":"adds methods to and . Unresolved questions:\nCan I nominate this for stabilization? It's a straightforward API with no real alternatives possible, and I had a real-world use case for it recently.\nCC --^?\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] [ ] 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-eb2f9b3bb39caefb93b615bcdd1a7a477ee66bea050804de4650e31a26511576","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. --Defining traits that contain methods that return such a type: The compiler should probably have warned me about not using the of the , consistent with the behaviour of async functions in Rust 1.67.0. This will also work without the need for traits but async traits is one of the most common use cases for such a type. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nWe looked at this as the wg-async triage meeting today. We agree this is a bug and that the behavior should be consistent with on and/or . This is also likely a good first issue for someone wanting to contribute to async.\nWould you say this is also a good issue for a first-time contributor to Rust? I'm not super familiar with the language, but I want to contribute to open source compilers, so I'm hoping to potentially take on this task.\nCan I take this ?\nEither one of you ( or are welcome to work on this! If it's your first time contributing to Rust, it might take a while to ramp up on it, but I find the best way to do that is to just do it. If you decided to have a go at it, feel free to ask any questions you have either here or in . I tend to watch #wg-async closer than GitHub issues, so you'll probably get a more prompt reply there.\nthis issue wasn't claimed so you are free to claim and work on it if you still are interested. Kindly comment with to claim the issue.\nclaim\nThis is also a very special case of"}
{"_id":"doc-en-rust-16845635e3831018a56fbab5a89a516a67a8c8004ce6fe80aff6afd5b41cb770","title":"","text":"Filing since it's in pFCP over at , and I don't think we can reasonably change it after stabilization (especially since it's documented). Currently, in release mode evaluates to . (And same for the other bases.) It's not obvious to me that that's necessarily the best option. For example, the implementation is slightly nicer on CPUs from the past or so (and I think would be just as nice on older ones ), but gives <subas u32</subin the wrapping case. It also might be nice to have the wrapping case give something clearly different from any of the successful cases, rather than having and give the same thing. For example returns in release mode, which isn't a power of two (according to ), so it's distinguishable from all the non-wrapping cases. This only affects // on . (The checked versions don't have an issue, nor do the ones on .)\nI couldn't find any previous discussion of what the exact wrapping value ought to be, just that there ought to be one, as opposed to a . There was this note: For which I think the implementation I mention above is a counter-example, albeit only for the base-2 case. Also, currently in release mode is essentially , so we can pick any value we want to return for those cases. FWIW, the implementation in gives as the result for .\nIn Rust we try to do the right thing. Not even Python gives -1. Let's avoid in-band error values in Rust.\nWhat's your proposal for what the \"right\" thing is, then? That panic in release too? Arguably the most-correct value is −∞ (like ), but that doesn't fit in any of our integer types. So would make sense, but release mode for the other un-prefixed things is wrapping, not saturating.\nPython has some functions that return in-band values: \"xy\".find(\"y\") 1 \"xy\".find(\"z\") -1 From Rust I expect something better. In Rust if a function isn't naturally total and you can't restrict its input, then I expect it to return Option (or Result), or when that's isn't ergonomic enough, a panic (in release too). Returning -1 is dangerous as that Python find function, returning 0 is not math."}
{"_id":"doc-en-rust-fbf7ca2720a5b84d779735158e477e946deaf8928bf458f061749ca37b4e24bf","title":"","text":"I think returning (wrapped if necessary) is a clear distinguish between normal and error result. Returning an is not ideal currently because it will makes the function practically unusable in const context (before const unwrap is stabilized) If getting closest to the \"correct\" math answer, how about choosing ? However it seems weird and still seems better to me\nPerhaps in other languages. Rust is known for being better than that. I have chosen to use Rust because it's a bit better than Python (see above). Let's return Option and and wait for const unwrap to be stabilized before making ilog const, then.\nThat's what does already. Is your proposal, then, that the version of just shouldn't exist on ? How do you square that with precedent of other things -- like or -- that have the version return , but the un-prefixed one wrap in release mode?\nwhat about treating it like division by zero and just panicking?\nI'd be fine with -1. The point of these methods is to get fast code (otherwise many won't use them and will prefer to do to keep the code branchless and avoid the ugly ) and a defined value outside of the usual input range. (from above) is a good example. If you want stricter guarantees than that, you can use .\nA minor point: being 0 is actually a reasonable choice - even though 0 is not a power of two, it is congruent to the correct power of two modulo 2^32 (which is 2^32 itself), so exactly what is expected in wrapping arithmetic. But unfortunately there's no \"−∞ mod 2^32\" that could be used for .\nModular arithmetic is confusing in the context of logarithm, if you want to return the discrete logarithm of 0 in the release mode, then there are a lot of candidates, because (in case of ) therefore in the sense of modular arithmetic, could be any multiple of . If you really want to achieve something close to , then I guess the best value is as I mentioned above. (Interestingly though, = , which is a multiple of 8, 16, 32, 64, 128)\nThat's certainly a possibility. suggested not doing that back in the original PR, though:\nDoesn't implicitly include a check for zero in the code generated?"}
{"_id":"doc-en-rust-a6d726bb543a3d79f485fcd8839136433bd3f20a147c51bfd0b422f18c0f9384","title":"","text":"]\nAlso, since the methods are implemented for signed integers as well, another issue would be the log of negative values. For example for floating-point, would return &minus;&infin;, but would return NaN. So if would return some value for &minus;&infin;, would panic anyway, or return some value?\nI don't think it makes sense to do anything other than panic in the case of negative values, which in turn is probably an argument for panicking on zero as well. I guess one could argue that \"wrapping\" could be interpreted as wrapping the preimage to fit in the function's domain (rather than just wrapping the image to fit in the range) but IMO that would be entirely unintuitive and unhelpful as well. After thinking about it a bit, it seems to me that simply cannot have a meaningful variant, because semantics (as reasonably interpreted) cannot answer the question \"what should the result be for values for which the original function is undefined?\" There are no elements in 's domain for which the function underflows or overflows.\nThat's only the case on old chips. As I linked in the OP (), that happens in the instruction generation very-last-phase of LLVM on old chips, and on newer chips it knows to emit a different instruction instead of the branching code: The good news is that it looks like newer LLVM has gotten smarter here. It used to be that, because of how the intrinsic gets translated, it would emit obviously-redundant assembly on old chips in some code patterns, as you could see in Rust 1.16:\nis supposed to find the largest so that . Since computers use wrapping arithmetic, the equation is better put as . The largest satisfying this equation in the case is (aka ). So if we consider a wrapping to be the inverse of , makes perfect sense (and is very efficient on modern CPUs, as others have pointed out). I would also advocate for to be as a method which always has this behaviour. [Edit: it already behaves that way]\nNote that's already how works . It's just that it wraps to in release right now -- this issue doesn't propose removing the panic in debug behaviour, just to figure out what the best value for release would be."}
{"_id":"doc-en-rust-27c613f3f8527b8326d9aea32362974a9087706fc83216eab7583f2aa3f6c584","title":"","text":"Since, from the notes, it seems like the libs-api meeting today said \"how about we panic instead of wrap\", I'll try to answer my own question from above: I would propose the following rule: Conceptually, the result is first calculated in true ℤ (aka to infinite precision). Then for the non-prefixed versions If that result is undefined (, , etc), then it panics (regardless of compilation mode) If that result is defined and fits in the result type, it's returned. If that result is defined but not in-range for the result type, it panics if overflow checking is enabled, and wraps (mod 2<supN</supfor uN) if overflow checking is disabled. I think that's consistent with all the current precedent. ( also is good reading about the distinction I'm drawing here.)\nI would redefine that to include cases where the result is defined but you can't wrap that to the result type, e.g. or . that would cover and\nI agree, but was considering that implied by \"in ℤ\", as that set includes neither −∞ nor ⅈ. (Like how is , not a complex number.)\nI'm not necessarily against panicking in that case. I just pointed out how it's a bit inconsistent with the other operations we have on integers. (Whether it makes sense for the other operations to have this difference in behavior between debug and release mode is an interesting discussion too, but I'm afraid that ship has sailed.) The reason we don't always panic on overflow for and etc. is performance. It's simply too costly to do. (We always panic on division by zero because that's both mathematically undefined (even modulo 2<supBITS</sup) and because on some platforms, the native division instruction will signal/abort/trap the program when the right hand side is zero.) We applied the same reasoning to things like and , although one might reasonably argue that for those it might be fine to always panic, since these are not as common as and . (You could then still use if you really want to make sure there's no check, if you're sure it's unnecessary.) That seems reasonable. It'd be nice if it'd still be easy to get the efficient calculation through some usage of or though."}
{"_id":"doc-en-rust-3ff2787f82c1b03a7c890a7f1b06135626f563d95989ca3a5b4fa4123a69a70f","title":"","text":"It looks like llvm isn't smart enough today to turn into simply a count-leading-zeros and a subtract instruction. :(\nWe discussed this again in the libs-api meeting, and we concluded pretty much the same as rule, meaning that these functions should panic on zero in all compilation modes, since there's not a modulo-2<supN</sup-correct result."}
{"_id":"doc-en-rust-4d3a55561d073ebb66923c8e15b6008c5d2560a7eb12bd917e265626672a4e1d","title":"","text":"Example: Results in the following error: of course, is by default unless you say , so the error and the suggestion are clearly wrong. And if you do say explicitly, you get Note being suggested, which is ~not even valid syntax~ apparently valid syntax, but not something you would write. I expected to see this happen: Either this compiles cleanly Or the compiler emits a different error that makes sense <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: (Seems to happen on nightly too.) </details\nDuplicate of\nReopening to track the error message, which is not tracked by . is just wrong."}
{"_id":"doc-en-rust-a8a4ce7a1f7159520cb23f17ce512eac52ede2baae114ca9b5c37a5c766ec511","title":"","text":"Consider the following code: This should just work. But instead it throws an error: The reason for this is that gets lifetime extended via promotion, so this reference now points to a separate mutable static -- but mutable statics cannot be mutated during CTFE. I see no way to fix this, other than stopping to promote mutable references -- which we should IMO do anyway, they are a very strange and unprincipled special case. Just imagine doing this in a loop, suddenly all these different and mutable allocations share the same address... Cc\nUgh, that's an ancient rule (believe it or not, it's a workaround for not being able to write and have the length be inferred!) and it was never meant to get this far, I guess I didn't think it through properly when adding the \"outermost scope\" rule, which is the only position where allowing it makes sense. In the current implementation, it should've never been promoted, only allowed, my bad!"}
{"_id":"doc-en-rust-0032656003d49486747818b78387703e152e7892a57c25caee873b32b608d81d","title":"","text":"The AVR-Rust post continues to track AVR-LLVM, which is tracking upstream LLVM. That means we are running into changes from the future LLVM 4.0. I figured we could open up this issue now to track the changes required to stay compatible. This is the current list of upgrade hazards. Note that some of the text may be nonsensical as I don't truly grok all the internals of LLVM so some changes are wild stabs in the dark. It's also possible that some failed fix for earlier problems actually caused later problems: [x] DIDescriptorFlags became a real C++ enum and not a bitset () [x] An EH personality is required for every function that can unwind () [x] pass changed header and constructor name () [x] changed API () [x] Bitcode/ReaderWriter.h has been renamed / API changed () () [x] changed API () [x] changed API () [x] prefers over () [x] string type changes () [x] is not guaranteed to be null terminated () [x] changed return types () [x] Archive support changed error handling types () [x] Teach Rust about an LLVM 4.0 API change for creating debug info for global variables () [x] Check all errors in LLVMRustArchiveIterator API () [x] Upgrade emscripten (kripken/emscripten-fastcomp, kripken/emscripten-fastcomp-clang) [x] Alignment now represented with 32 bits instead of 64 () [x] API changed again () [x] now takes an instead of a and () [x] Symbol lookup error when linking dylibs () [x] Undefined behavior in tests () [x] Unoptimised builds of compilerbuiltins on ARM have references to () A WIP PR that performs the upgrade! Some issues whose resolution is believed to be blocked on LLVM 4.0: [ ]\nNext time we do this upgrade we'll need emscripten to do it to. It would be good if we could pull in a working llvm wasm backend in the same upgrade, but that may not be ready before the end of the year.\nFor the record, I am also working with a fork of LLVM that is tracking upstream (not AVR-LLVM but similar in spirit) and am starting to work on this now."}
{"_id":"doc-en-rust-b825ff3dc6ae4176fd7ecfcfa06ff0a46c85d7baa86a087f5f86be03408e3df4","title":"","text":"I'm looking through the AVR-Rust commits and I'd love to coordinate --- feel free to ping me on IRC () or via mail!\nNote that there is a regression reported against llvm 4.0 regarding the powi intrinsic on armhf targets: I'm explicitly mentioning this here, because there were previously problems with it, see and related issues. Also cc rust-lang-nursery/compiler-builtins, an issue about the same problem in the compiler-rt rust port.\nTo clarify what I think the is referring to (correct me if I'm wrong) In LLVM 3.9 and before, the calling convention LLVM used with the powidf2 and powisf2 intrinsics was basically the C calling convention In LLVM 4.0, the backend was corrected to expect these intrinsics to have the aapcs calling convention One person that aapcs is expected for powis2f and powid2f, while another a claiming that the normal C calling convention should be used. So it seems that if the LLVM change is not reverted (expected powisf2 to be aapcs) then we need to update our definition. This is going to be a huge PITA for supporting multiple LLVM versions as well. We need to select the calling convention depending on the LLVM version as well...\nAny objections to doing that coordination here on GitHub, or on one of our forks?\nI don't have strong preferences for the communication channel.\nshould address what is listed as API changes\" above (the core of the change is in how attributes are represented).\nI would prefer to upstream LLVM 4.0 compatibility patches sooner rather than later. That includes my own work obviously, but I'm also looking at the commits I cherry-picked from AVR-Rust. In particular, looks like a reasonable simplification even independent of LLVM 4.0 compatibility, and looks like a nice little self-contained fix. Could you create PRs for those? (If you don't have the time but are otherwise fine with upstreaming, I'd be happy to manage that, giving proper credit of course.)\nAbsolutely! I wasn't really sure how much we could expect LLVM 4 to change as it goes towards stable / how much churn the Rust maintainers would want to put up with. I'll get those pulled out and submitted soon. I think I'm also starting to understand some of the silly error handling that the new LLVM does."}
{"_id":"doc-en-rust-d8c508b539f75924a09b687b12d456595d2134b4f4d573dca0ee6458541c00a8","title":"","text":"Awesome, thanks in advance!\nBTW the PR reference for \"llvm::AttrBuilder changed API\" is wrong, it points at this issue instead of\nDoes anyone have ETA? I'd like to know when I can use AVR. :)\nYou should follow along at avr-rust/rust for the AVR-specific issues. Upgrading to LLVM 4 will not magically yield AVR support.\nOk, thank you!\nI've created for the API change.\nI've also created for another debug info API change.\nAfter putting all of those patches on top of master, was successfully built. I got several undefined references, most likely due to my local LLVM setup.\nI think the next step after all those patches land is to allow LLVM 4.0 in the configure/rustbuild scripts and then actually update the submodule.\nWe'll also need to fix that AAPCS bug first, I just noticed it\nDon't forget : I think that means that the Rust fork of LLVM is following the Emscripten fork of LLVM, thus Emscripten needs to upgrade to LLVM 4.0 / master before Rust can.\nAnd I'm hoping to supersede it with\nI just ran into which changed the alignment from u64 to u32. Will think about a proper fix later, unless someone beats me to it (but should merge first to avoid further conflicts).\nAnd it says So, that will be \"exciting\".\nIs there much left blocking an upgrade?\nThis: Has to be done too but I don't know if it's currently being worked on. Any info on that ^?\nNo nobody is actively working on an emscripten upgrade. Since even when that is done it will probably take a lot of work to land an LLVM upgrade, there's probably more we can do to prepare. Once we decide we want to do it, somebody can prepare a patch to throw at the bots. It seems likely stuff will not work and it will be a slog to fix it all, which will give us time. We don't need emcc to generate wasm stds, just a fairly small patch on our LLVM branch that will hopefully port without much difficulty. So if somebody feels motivated, it's not too soon to start going after it. As to the emscripten upgrade, we should at least let know that we're starting to think seriously about doing the upgrade, and need emscripten to upgrade LLVM too."}
{"_id":"doc-en-rust-3f7c24e04e18bdd9163f17d7c308a4e17719371a2d0e199a0b9e560bd6cb202e","title":"","text":"It seems like that could be a big effort. Another alternative is to use the LLVM wasm backend, but I still have not heard that it is generally usable yet. cc\nI can look into the effort needed to update emscripten's fastcomp LLVM version, but I need to know a commit to aim for. Sounds like the goal here is 4.0, which hasn't released yet, so I guess I have to wait on that?\nSo far as AVR is concerned, any commit within the last month will do. There will likely be a few more months until 4.0 is actually tagged (every ~6 months a new release is made). It is quite common for projects to track LLVM master, which I'm personally a fan of.\nBut is it common to release snapshots from LLVM master? When LLVM itself only releases every 6 months, it seems incongruous for Rust to pick arbitrary snapshots in its 6-week release cycle.\nLLVM 4.0 will branch in a week and the final release will happen in late feburary (schedule says 21st for final tag, but this is flexible IIRC).\nFrom the llvm-dev mailing list:\nbranch has happened\nAn update on the \"powidf2 / powisf2 calling convention changed\" situation: The regression has been fixed on llvm master () however from what I can tell the fixes are not yet in the 4.0 branch, although the fix may be backported ().\nI've started working on updating emscripten kripken/emscripten-fastcomp kripken/emscripten-fastcomp-clang I've also created a new bug requesting that the regression fix be merged into 4.0 .\nsays the emcc LLVM upgrade is ready to go. or are we prepared to begin the Rust LLVM upgrade? I think what needs to happen is to submit the Rust PR and start throwing it against the bots. Once it looks like that is close to landing then we'll have to coordinate both project's upgrades to minimize the breakage window where rustc and emcc have different backends. I'm not sure how best to do that - we might just try to upgrade as simultaneously as possible and accept up to a few days of breakage, or we might ask emscripten to stage their build such that they can swap their incoming branch right after we land to master."}
{"_id":"doc-en-rust-d08d57ad91dcd821a66e6bf4a09770d40ddb42dd5816a251300a62a967ffb4ed","title":"","text":"needs to know the exact LLVM commit we're moving to as well, and that will become clear once the PR starts working through the queue. The stars are aligning. Let's make this happen. Thanks for doing the fastcomp upgrade.\nWe are not fully compatible with LLVM 4.0. I have heard from at least one person (on IRC) that building against stock LLVM 4.0 (RC) does not work. I haven't personally inspected all failures, but there's at least two things still missing: (and possibly ). It shouldn't be a conceptually difficult patch to apply the equivalent changes to rustc, but possibly a big diff. I haven't digested the implications yet, but it might be a relatively simple change localized to the function in that currently calls .\nThe fix has been merged into the 4.0 release (). I'm going to try and build Rust against stock LLVM 4.0 and figure out what needs modifying.\nOn top of what mentioned: now takes an instead of a and ()\nI've got a half-baked patch to use the new signature for I'm not familiar enough with Rust internals to finish it off. I ran into a problem in as it is given a but in order to use we need a . We need to call in order to build an instance of .\nI've opened for the change that mentioned. I've also opened for the 32-bit alignment change. I believe that is the only thing we need to update aside from these two PRs in order to get the compiler to successfully be built with LLVM 4.0.\nSo to summarize where we are with LLVM 4 (correct me if I'm wrong): 4.0 will be released in about 1 week (2/21). are no known issues with supporting LLVM 4.0, but there are probably issues that will be discovered once we try to use it in nightlies. runs on in-tree LLVM + LLVM 3.7 (so PRs haven't actually been tested on LLVM 4.0 yet). support LLVM back to ~3.6(?"}
{"_id":"doc-en-rust-6ee5ceb18eabad3b778a81eed6b79cb6832e65aaa7bebd81d106c9ad178e134d","title":"","text":")~ 3.7 and will continue to support it until either: a. It's so old that it can be removed without bothering package maintainers b. We need at least version X in order to fix an important bug c. The API is so different from version Y that it's a huge pain to support will open a PR to update the submodule shortly after release but it will take a month to land due to: a. Waiting for emscripten ( -) b. Bugs in upstream c. Missed LLVM API changes d. Making bors happy e. All of the above\nThanks for the summary The only correction I'd make is that in your point (4) you can s/3.6/3.7/, but otherwise it's accurate :) If you'd like to start preparing a PR to update to LLVM 4.0 I don't think we need to block waiting for LLVM itself to release 4.0. Currently only one Travis builder runs on each PR but we could temporarily allow more builders running on an LLVM 4.0 PR to start weeding out bugs before it hits\nI gave it a go but I don't think my git-fu (or patience) is strong enough to handle a big merge like this. What I can do is try to run rustc with upstream LLVM and file/fix issues as I find them. There is at least one issue remaining as of (details to come).\nWhoever ends up doing the LLVM upgrade, please also upgrade the compiler-rt submodule so that the sanitizer related LLVM passes don't diverge from what the sanitizer runtimes expect.\nIn fact, if you upgrade before the release, they usually mention your project in the release notes. :)\nSo whats the next issue(s) to subscribe to in the race-to-AVR? :)\nAs says on , we can integrate the latest Rust master into the avr-rust compiler. After that, we can spend some time getting compiling for AVR. Once that is working, we could then start looking into upstreaming the AVR target to Rust.\nAVR-specific issues can be raised / tracked in For example, there are two that I'm aware of right now:\nhas been closed, so that can be checked off in the top post."}
{"_id":"doc-en-rust-7d0e41f583374c24af112120ecdc9c7bfb9766f11dbcaf58cbdfd7089d1eadef","title":"","text":"The compiler could suggest that identifier must precede the pattern in the following code: playpen link: Current error message: It could be improved as:\nmodify labels: A-diagnostics C-feature-request T-compiler\nSo what happens after is that we've parsed a and then follows which is not a valid token after a parsed . To fix this we can, after having parsed in , check if follows and then emit appropriate suggestions. We will need to use some heuristics to figure out what the user wants based on the structure of . Some of the suggestions would be and some not. cc"}
{"_id":"doc-en-rust-2e0737e48d194283ecdca8a263eada474aded75306ca35812d4cfc302a03e81a","title":"","text":"() As you can see, calling directly doesn't instantiate the HRTB (even though it needs to AFAIK) or if it does it doesn't normalize the resulting bound, whereas going through normalizes the instantiated argument types of , while 's definition can be type-checked as-is. EDIT: you can also get an ICE by uncommenting the use in : cc (this might be a duplicate)\nDuplicate of (at least the ICE case)? A lot of analysis wad did in the other issue. Maybe it would help. I doubt that, in such cases the associate type do normalize at all. My assumption is: In the case that you marked as \"working\", it is just delayed the normalization to the later stage. So if the later stage consider this is dead code it is passed and compile, otherwise, when it really need to normalize it, run into ICE. So when called explicitly like , the compiler have no choice but to normalize with . If you instead though, the compiler checked that the requirement to match the argument can in theory fullfill, but the lifetime parameter was not free in the function body so it can consider this is a late bound. So the normalization is not happen right away. Later on, when you add the code in to call , the compiler have to do normalization again, but it is already in codegen (see the backtrace messages) phase, so normalization is unexpected and ICE occurs. Given all that, I guess a proper solution is to add a \"late normalization\" pass to normalize any postponed normalization like this.\nThis is a probably a duplicate of and/or ?\nclosing as duplicate of , which is where I will try to track future instances of this field of ICE."}
{"_id":"doc-en-rust-b05831725aaee5c6b4762d6cebceac0d5931154ab4f2a261f8ef9a436bc66084","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: print (from Debug impl) Instead, this happened: E0277, trait impl not found This was found by CI in the Ruffle Project: The issue is caused by the effective anti-bound of Drop, introduced by the manual impl of the trait, as well as the PR which introduced bounds for a number of functions in . It most recently worked on: rustc 1.59.0-nightly ( 2021-12-18) : modify labels: +regression-from-stable-to-nightly -regression-untriaged\ncc"}
{"_id":"doc-en-rust-b7e390309a6f67da1853cf1778ae02200c8164e5e0bb09ae6c126ec5ad105100","title":"","text":"Here is a complete (minimized) reproducer: It can be reproduced with a workspace with two crates \"a\" and \"b\" where: The crate \"a\" depends on the public () crate and its code is: . The crate \"b\" depends on the workspace crate and its code is: With that setup, the command rightfully succeeds using the stable toolchain. But fails when using the latest (2022-04-25) nightly toolchain. The bug is observable on nightly only (works fine on stable, and beta) : <details<summary<strongBacktrace</strong</summary<p</p</details\nFixed in"}
{"_id":"doc-en-rust-e2ad4b52738af25b28d330b9db3e2ab4fbb26ca5cce4b94bd69a3534ceeaccc9","title":"","text":"See: The keyword hasn't been introduced until that point but it's used in the code example which is confusing. I believe an if/else solution would be more explanatory, especially because the reader probably wants to see how to unpack the variant of . The same enum could then be used with the keyword in the beginning of the next chapter ().\nYou are correct. Nice catch!\nAre you ok with simply reordering them ? Because introducing sum type without precedent knowledge of pattern matching is a bit pointles (or at least misses the fact that they are juste AWESOME for pattern matching). If you're ok with this I'll PR in a few hours :)\nMaybe, if it flows okay, yeah. I do want to put SOME kind of mention of it first.\nIt's probably easy to find out what is doing by simply looking at it. This part of the tutorial is just a bit confusing and should be fixed. However, my main concern here is that the reader is left clueless on how to solve this problem with if/else: In fact, I really don't know how the equivalent code without would look like. I've briefly tried to figure it out and gave up.\nWith an Option you coul unwrap I guess. By the way why did you write a fake option enum ? Because that's basically what is done with this, it might be better to give out the real name\nBecause we haven't talked about generics yet.\nNicely done. However, my other concern, how this example could be done without , remains unresolved. I'm certain that I'm not the only one who wants to know how it works with before continue reading about . Should I open another issue for that matter?\nI'm honestly not sure that it is possible with an arbitrary enum... You can test for some arbitrary values but i guess but that's it. Bt it's more an issue of sum types in general rather than a Rust issue (I can't find ways to do that in haskell nor in scala)\nAlright, I expected something like this as I was unable to figure out how to write it without . I don't have much experience with statically typed languages, therefore the concept was new to me. If you are right, could we mention in the tutorial that it is actually not possible to write an equivalent solution with ? Certainly, I can't be the only one who was a bit puzzled."}
{"_id":"doc-en-rust-be6b0474da10c9d4a3d1c3d52a0445cc5bf1118265c9960d01ead7c6981581b8","title":"","text":"Cheers.\nThanks a lot for the remark, it's exactly the kind of comment needed, if you see others don't hesitate to open new issues :) I'll try to add this tonight or tomorrow."}
{"_id":"doc-en-rust-165d89f539c3ce756ddff3a662687fb727b2b42ab91cc282c32b5e13623e74e1","title":"","text":"For generic types, the prelude collision lint can produce suggestions that do not compile: Code: Suggestion from the prelude collision lint: Error after applying the suggestion: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc\nMy guess is this should be a simple fix, just copying the code the lint already uses for adding unspecified generics (). Will try implementing a fix soon.\nassign\nrelease-assignment\nThe code related to this lint lives in the . The relevant suggestion is generated here: The \"self type\" string comes from here: The code for traits is here: This is actually just a touch tricky, because currently we are getting the \"self type\" just by copying the text the user wrote. Probably the most correct thing for us to do would be to examine the 'self expression' HIR and, if it is a plain path, then to append the and otherwise skip it. Specifically, the other case that I am thinking about is code like this: Currently , meaning that it offers the suggestion \"disambiguate the associated function: \".\nclaim\ngreat! Let us know if you need anything or make progress. This issue is fairly time sensitive.\nrelease-assignment\nclaim"}
{"_id":"doc-en-rust-4fd363e3c2caaa69ef789bf01f16038e09b968a59dfd250a6cc32eb3d0bfb237","title":"","text":"This gives the very unintuitive error: You expect to return , i.e. a . It mysteriously returns an instead. Because has a clone impl, it too, can be cloned (really, copied), returning a reference of the same lifetime. This is an operation you rarely want to do explicitly, except when dealing with generics. This error can crop up when you've forgotten to implement on , and have a reference (which could have been silently inserted using , as in the code above). However, it's not very obvious what's happening here. It can also crop up We should hint that itself isn't cloneable and thus we fell back to cloning here. This could be a lint on hitting the clone impl for references, but lints run too late. I'm not sure how this can be implemented, since we need to see the source of a value and that's a bit tricky.\ncc\nInteresting. This does seem like it would require some pretty special-case code to achieve, but I agree it'd be a nice case to capture.\nA relatively easy way to catch most instances of this is to Pick up the expression which has a type error like this If it is a method call, check if that method call is a clone() call resolving to If it is a variable, find the variable's def If the def is a local def, look at the init expr, check if it's a bad clone This will miss things, but I think the majority of such bugs will be due to this. As it stands this feels like an incredibly easy case to hit (we've all forgotten to decorate structs).\ncc\nCC\nAs reported in : This reports:\nCurrent output is even worse for the original report: The last comment's code is marginally different:\nCurrent output: The last case should suggest constraining . Edit: that was easier than I thought (we already had the suggestion machinery): <img width=\"511\" alt=\"Screen Shot 2022-12-13 at 6 41 23 PM\" src=\"https://user-\""}
{"_id":"doc-en-rust-083ab7db4e2d48777362fd29f1c6170eec0fa54a54f82e95b6d3b4e25b7c55d1","title":"","text":"Regression from to . The following code yields an incorrect error: On beta, this gives: On nightly, this:\nwould you be so kind to label this issue? It's sliding down the list while being hard to search.\nRegression occurred between nightly-2020-06-23 and nightly-2020-06-24, I suspect is related (it's ?).\nIt would be great to find the culprit PR. ping cleanup\nHey Cleanup Crew ICE-breakers! This bug has been identified as a good \"Cleanup ICE-breaking candidate\". In case it's useful, here are some [instructions] for tackling these sorts of bugs. Maybe take a look? Thanks! <3 [instructions]: https://rustc-dev- cc\nsearched nightlies: from nightly-2020-06-23 to nightly-2020-06-24 regressed nightly: nightly-2020-06-24 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.5.1</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </detailsIf we rule out document changes then we have\nBisection seems to confirm this, cc\nWith a little more git bisect it seems is the first bad commit And I guess the change to the test case also shows that\nAssigning as and removing .\nWell, I can certainly imagine how this could come about as a result of the leak-check moving, since the same error can now be detected at a different point during type-checking. What's happening in that confusing error, I imagine, is that we are now winding up with a \"universe error\" that comes out from region checking. The identity function was inferred to take an argument for some ... Well, in short, I imagine that the solution here is to improve the error reporting for the new point where the error occurs, but it'll take a bit more digging to give good mentoring instructions into how to go about doing that.\nThis is now a stable regression.\nDiscussed in T-compiler meeting. Seems related to (or potential duplicate of) ?\nOn today's nightly, the error is now: That seems correct, and with the extra lifetime, the snippet compiles:"}
{"_id":"doc-en-rust-0d320e0b0c6a37a342950363acf304bfe2cbded54e777c1b4db89b4bba1069b1","title":"","text":"An error message indicating that a full (or at least longer) git history is required. The correct link would include a commit hash inbetween the . But the required commit hash is not available because there is no full history. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nHm, can I do this? label +A-rustbuild\nMentoring instructions: find what this command outputs when the repository is shallow: If it's an error, see if you can check for a shallow repository somehow and give a hard error instead of continuing onward just to fail.\nNote that this shouldn't need to the full history of the repo, just the past few days, since PRs are constantly being merged.\nWe should only need one (bors merge) commit, I believe - each bors merge has the full set of artifacts.\nThe command prints nothing in my shallow clone. There is a bors merge commit in my shallow clone though: The command before used to work for me -- I was able to enable in my shallow clone. I tried to fetch more commits, and then started to work: But still prints nothing.\ncc I would have expected the git log and git rev-list to be 'identical', in some sense, so perhaps that's something worth filing upstream as well. But regardless, I am inclined to revert to fix this issue; it was primarily a 'hopefully more robust' solution and to my knowledge wasn't actually fixing any known bugs, so since it caused a bug seems good to revert it for now...\nI think it's possible that the shallow clone is causing the predicate to fail. Note the decoration in The git documentation implies that shallow clones use something akin to the (fake parentage for commits) facility for shallow clones. Maybe removing is sufficient? I'm a bit wary because bors seems to create non-merge commits on occasion (for squashes), but maybe it never does so on the first-parent history. I haven't had a chance to poke at a shallow clone in detail yet.\nI'm seeing a similar problem for git worktrees, not just shallow clones. EDIT: this may have been a separate reason, it just had the right timing\nWould love to see movement on this."}
{"_id":"doc-en-rust-975f7d5453a0f1cd99c87683a7c488fb36248820910995b76a7b321057dad14a","title":"","text":"I don't want to allocate ~20GB of laptop space to a deep clone of the repository in order to simply be able to build the compiler. When i was messing around, removing \"--merges\" as suggested did the trick.\nfeel free to make a PR with that change :)\nI wasn't sure if there was some reason not to do that: I'm a bit wary because bors seems to create non-merge commits on occasion (for squashes), but maybe it never does so on the first-parent history. I don't really grok most of what said there, but if you think that's a safe change, then sure thing!\nAs long as we keep first parent, dropping merges should be ok, any commit in the first parent chain should have artifacts (if it's recent enough).\nI would appreciate knowing details of what behavior you're seeing with git worktrees, if you're willing to provide them.\nSorry, I'm not seeing any related problem when trying to do a simple test with worktrees. I do see a problem with shallow clones. Could you please describe what you're seeing? Does it still happen if you delete the options from the command lines in ?\nI don't think we need to exhaustively catalogue the issues - even if removing --merges doesn't fix all the issues it will fix some of them, and we can make more improvements in follow-ups.\nclaim\nSomeone should probably file a bug about failing to see merge commits in shallow clones. I don't feel like I understand the issue well enough to do so."}
{"_id":"doc-en-rust-909c854c9e85845042d7d8a745db55ef4e07f84f9161a0a54ccbd457f7aa3472","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: Instead, this happened: Apparently, taking a shared reference of will suppress the lint. This seems like a false negative. While false negatives can't be avoided entirely, this case seems to be avoidable as taking a shared reference shouldn't change the type of (which is ) or modify any data in this example. Note that will trigger the lint properly. : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nSee also .\nclaim\nNote this is a problem because which is supposed to fail to compile but this bug makes it fail at runtime instead\nIn case no one has dug into it yet, the error is suppressed in but not in and before:\nlabel +regression-from-stable-to-stable\nWG-prioritization assigning priority (). label -I-prioritize +P-medium\nThis is caused by . It only ever worked because the lint ran after optimizations. I made a fix . It specializes the length of arrays as constant, even if the array isn't. I'm going to open a PR when I have time, probably tomorrow. In the long term, I'd like to implement some more extensive tracking of \"what parts of a value are constant\". For example, the compiler currently assumes that anything that had its reference taken can change, but actually, this can only happen inside (as I understand it).\nLabels from the closed duplicate , label A-diagnostics, A-lint, A-mir-opt, T-compiler.\nFixed on stable label E-needs-test\nI claim the add test part\nThis lint only appears on full builds (not check), but this will be fixed once lands.\nReopening because I feel this is not yet solved, see on . As per the , should nail down this issue?\nMRE: Also, duplicate of\nAnother variant of this same issue:"}
{"_id":"doc-en-rust-f40da6bbbde4de88a2290bafc3ce0e373e1219b0344290814791bfb8a877a43c","title":"","text":"The behavior of .consume when the buffer is empty is weird : while :\nCurrently the contract of is that you can only pass a number the number of bytes you receive from . In this case the method is never being called, causing the weird behavior. I believe this is a documentation issue as the documentation for the method is pretty curt.\nMaybe adding an assert_debug to check that could be useful too ?\nWhat's the intended use of if it must always be passed a value the return value of ?\nOh sorry, I meant ! The function is intended to tell the buffer how many bytes you've consumed from the return value of"}
{"_id":"doc-en-rust-8444c0bfcd41b7e84e100da94304ae51b51ce92f6982f9e921c5d0af99035acc","title":"","text":"thread 'rustc' panicked at 'index out of bounds: the len is but the index is ', ../src/libserialize kind of expected, after switching toolchain from 1.15 back to 1.14. cargo clean && cargo build \"repaired it\"\nDo you have some more information on how to reproduce this?\nI hit this compiling hyper with 1.13 stable.\nWhich version of hyper is that? I can't reproduce with latest .\nIt was with master. I tried and now it works. So rustc/cargo were using libs compiled when I tried this with 1.15nightly?\nSounds a bit like cargo was re-using libraries that it should have re-compiled because the compiler has changed. cc\nSorry if I did not save the full backtrace - It was my first issue report. I switched away from 1.15 nightly back to 1.14 nightly in order to solve a serde macro issue. Cargo cleaning and rebuilding fixed the issue. I will make sure to run again and capture the output if it happens again. On 11/16/2016 4:54 PM, Michael Woerister wrote:\nSounds suspiciously like a Cargo bug! If there's a reproduction I'd be more than willing to dig in.\nI believe I just reproduced this in Cargo itself: When executing with the last few lines are: So what's happening here is: is populating the entire crate cache with a bunch of libraries on the nightly compiler. switching compilers, Cargo decides to recompile everything. doesn't delete everything as it recompiles, rather incrementally builds up a new crate cache compiler, given to that directory, will read crates in that directory. compiler panics when reading a crate compiled by a future compiler. So I take back what I said earlier about this likely being a Cargo bug, it seems like this may be a bug in the compiler trying to read stale metadata? I thought we had like 10 checks in place to ensure we didn't do that, but maybe it's still leaking through?\nI'm going to tag this as a stable-to-nightly regression as this appears to have been introduced in nightly. If I build cargo with beta and then switch to beta, the compiler doesn't ICE.\nThe panic on stable happens in we check version information. Did we change how we encode version information?"}
{"_id":"doc-en-rust-067ec356d1a42001a3b072faa160d84ee049355a2bb38f70918a28c890f4479e","title":"","text":"cc\nI incremented the header version number though... It should be impossible for older rustc to get that far.\non it looks the same on . Perhaps we just need a PR to bump that?\nOh it looks like my changes have reached stable. I wonder if perhaps the is in a precarious spot and/or has been moved or the serialization otherwise changed. This requires further investigation.\nWhy is this even calling leb128? Are we using variable-length integers in the metadata header?\nI assumed leb128 was the crate being built, not one used by the compiler.\nSure enough. Now every change to requires us to update the LLVM version number, because checking the rustc version number requires parsing . I think we should go back to JSON version guard.\nAhh that's what it was. We can put it at the start then, before/after the absolute address. I'd forgotten that the whole struct would have to be decoded.\nWhat was the PR that modified the versioning scheme? I gather that something has changed about it. Can somebody explain more clearly what is going wrong here?\nI mistakenly put the version string inside a larger , somehow thinking that it being at the start helped, but if the whole (that is, ) can't be decoded (e.g. because its definition changed) then you don't get to see the version string, whereas before it was separate. The fix would be to separate it again, put it back at the start and leave it there. Or just encode/decode it before instead of as part of it. Either will work as long as it can't be affected by changes to the metadata schema. The PR that introduced the new schema was , although breakage didn't happen until changed later, for procedural macros and/or the name resolution changes ( would know).\nremoved the field from for macro modularization.\nI believe I have a fix ready. Does this affect beta too now, or just nightly?\nAFAIK it's just nightly, not beta or stable"}
{"_id":"doc-en-rust-9a994ebf459940df871763a70de91670c66bd2d2064028ac59873b47fceaf38d","title":"","text":"This can be replicated with a minimal : Compile it to WASM with Then, check if the generated WASM uses reference types: <!-- Provide the most recent version this worked on, for example: It most recently worked on: Rust 1.47 --It most recently worked on: (and previous stable rust versions) On those versions, compiling the above and then running with doesn't fail. <!-- 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 -- modify labels: +regression-from-stable-to-nightly -regression-untriaged This seems to have been caused by The compatibility note there says: However, the generated code seems to be indeed affected by default. Interestingly, reference types seem to be used unnecessarily, as using to turn the generated into wat and then to turn it back into wasm removes the reference types. As-is, this breaks compatibility with the WebAssembly 1.0 spec.\ncc Looks like this causes issues in practice and we might want to do after all?\nWG-prioritization assigning priority (). label -I-prioritize +P-high\nI was unable to confirm the presence of any reference type instructions in the generated Wasm, even though I got the same error pointing towards a that looks perfectly valid to me. Interestingly enough, doing the back and forth conversion with and remove the issue, even though the output of both files is exactly the same, apart from the missing debug information. I'm assuming that this is another example of a tool making use of the , so this was already anticipated. Unfortunately (?) this isn't the first time LLVM has enabled features by default, in the past they even did affect code generation. From what I've read in the various WebAssembly specification groups, this was always intended. In conclusion, I agree this is a form of breakage, it seems to be intended, I believe if Rust wants to do anything about it the solution needs to a bit more comprehensive. E.g. actually disable all target features by default (I don't know if this is feasible with LLVM, would need research). See and .\nI just spend some time digging into this error message that spits out."}
{"_id":"doc-en-rust-fa3c5021d187e8df63e1eafdaa29d9634b378a011c56e0521fb60a5d79be1ced","title":"","text":"Locally I've produced exactly the same message, but it really doesn't make any sense to me. The location pointed out by the error message does indeed contain a call to , but the reserved value is , so I don't know what the issue is. Further, after using the -trick, it doesn't produce this error anymore, but the code location contains the exact same bytes. I also checked if reads the target feature section. While I confirmed it does, I don't believe it validates it from what I can see in the code. So maybe there is some sort of codegen difference, but I am unable to actually find it.\nCould it be the encoding difference discussed in the description of this PR?\nYes, I just confirmed that's the issue. So it does affect codegen, even if in a minor way!\nYes the problem is the LEB-encoding of the table index immediate. Using on the output of rustc I see: which shows that 's type and table index are both using a 5-byte encoding of a zero value. This is not valid in MVP WebAssembly which required the table index to be a literal zero byte, not a LEB. Given I doubt LLVM will do anything here so it sounds like yes, we'll have to solve this in Rust. I believe this is due to the the binary encoding of the LEB. This isn't reflected in the text format and most other tools don't handle this well, so it's a subtle error. That's also why convert-to-text-and-back produces a working binary. To clarify, I don't believe that this is the case. I believe modifications to the target feature section are unrelated. Ok so the question now is what to do. I see a few possible routes: this change. That would entail updating the release notes for the LLVM upgrade PR to indicate that wasm targets are indeed affected. This would probably also detail the workaround of . Note that may not be enough given in . 't accept this change. That would require something along the lines of , perhaps modified to use then adding on features afterwards. \"Fix\" this change. This would require coordinating with upstream LLVM to change how this works. My guess is that given the existence of this seems unlikely to happen."}
{"_id":"doc-en-rust-297d3400e1b2cdd8e72d748289993ddac2744f2f1e8530d4381495ace00c683b","title":"","text":"There's not really a governing body per se around the Rust WebAssembly targets so there's not really a group of people we can point to and say \"ok please tell us what to do\". In lieu of that I would personally be tempted to go with route (1) because that keeps LLVM/C/C++ aligned with Rust and prevents divergence in the wasm ecosystem. Given the age of the proposal and the general intention for enabling more features by default over time as popular engines implement them this will also continue to change. So, concretely, I would propose: Do not change code as a result of this issue, leave it as-is. Update the release notes for LLVM 19 to indicate that WebAssembly targets are affected Update the WebAssembly documentation to explicitly document how to achieve and \"MVP binary\" by using and .\nin the compiler team triage meeting. We think plan is reasonable at present but if there are additional issues or complications (such as it being more difficult to create an MVP binary than just using ), then option 2 (use by default) seems to be the way to go.\nLooks like there may be complications. I am endeavouring to add a test to CI which asserts that a particular compiler invocation will generate MVP features. So far roadblocks are: Using is not sufficient. The attribute is not rewritten for IR of dependent libraries, like the standard library. That means that is only applied to the local crate and the standard library still codegens newer features. One can fix the above issue to additionally use but you'd have to pass for all active features. Not great. Even with there are still bulk-memory instructions in at least for example. These are coming from wasi-libc for the target which is what rustc tests in CI. This is not applicable to this issue as users typically use for this but would make adding a test difficult. Trying out the target locally I can't even get something to work it seems. LLVM is producing an invalid binary with alone when there's a memcpy in the binary. There's... a lot going on here apparently. Given the above I don't think that (2) I described above is a silver bullet by any means, even that seems doubtful to work. I need to investigate more what's going on here with all these features slinging all over the place.\nTesting shows that plus Cargo's is sufficient."}
{"_id":"doc-en-rust-67cdbadfee0d5f07d94b58ff24a7176ce2bb09c1eb7307f652b91d28c77a7817","title":"","text":"That's more-or-less the same as (1) so I'll take it on myself to document this and get it all written down. Unfortunately that doesn't lend itself well to a test in-repo but that's not necessarily worse than where we are at today.\nI've proposed to close this issue as \"this change is expected\"."}
{"_id":"doc-en-rust-ef55daec89c8196b1014278c45fc5c96d06b55542a51c52d2bb1e4e3f7f414ca","title":"","text":"and WebAssembly book () In Rust some requirements for WebAssembly targets. This makes Wasm binaries compiled with Rust (at least with default options/out of the box std) incompatible with older runtime environments, in particular not-so-old iOS safari (). Here is for example the support for Safari iOS 15.5 simulator: ! I searched but did not find any place where these requirements are written down. I think that this is a problem.\nIn principle Rust can produce binaries that only target the core subset of wasm 1.0 just fine. You do need to set some additional options with and build your own standard libraries though. But point taken, is missing dedicated pages on the wasm target that could contain this information.\nThe 2nd sentence right after the one you quoted outlines exactly what you need to do to take advantage of rustc’s capability to emit outputs to the wasm 1.0 spec (or any superset of it:) Make sure to do this and report back if you're still seeing the unexpected instructions/types/other entities after rustc is told to produce wasm binaries the way you need them to be. AFAIK, not for WASM.\nSorry, I realized I misunderstood your answer and deleted my post while you were answering it. Do you know how to show which features are enabled by default for a given target? I searched and did not find. I'm trying to discover whether is enabled by default on nowadays. As it seems to be because I am seeing types in the emitted wasm, even though I disabled the feature by \"\" in an environment variable RUSTFLAGS. It would be surprising to me that is built with that feature by default on wasm32, but maybe it is.\nHm, I'm actually not sure why you might be seeing simd128 in your modules. As far as I can tell it is not enabled by default for any wasm target. In order to print out features used you should look for lines in: For what it is worth I’ve been using this exact target at my $DAYJOB with a pretty primitive runtime and it has been working largely OOB if my memory serves me right. So it indeed could have something to do with your dependencies possibly using something like ? Not sure!"}
{"_id":"doc-en-rust-2c3dd642527c1e93cb2ba7b38f548e3ac47f42628a2b28d30fe7e2627b3b1259","title":"","text":"It seems that the was built with as I see this WASM function: What I am not sure is whether 1. this was integrated with the standard library and then imported indirectly to my project, or 2. somehow one of the dependency managed to enable it by itself. I tend to favor 1 but I'm not sure. That is why it would be great for such things to be documented :-)\nFor reference, I asked on the about how the std lib is built.\nI confirm that as of version 1.75, the standard library is not using any WebAssembly SIMD instructions. Here is my test: which shows nothing, so they get pulled in by the memchr package through some of my dependencies.\nYou yourself pointed out which crate produces the v128 types: . It uses to enable emission of these types, regardless of the global configuration it looks like. This is usually fine for other architectures, but rarely for wasm, so it might make sense to file an issue over there.\nI fully agree and I just opened an issue there: BurntSushi/memchr\nAs a heads up I've proposed that close this issue with documentation of how to target MVP wasm."}
{"_id":"doc-en-rust-8c1f9405160e12d30006c667b439273c81bd50e5ad038ce671714f9c5a7d2a66","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 to build a wasm binary with MVP opcode only, so I disabled the features: I expected to see no in the wasm binary. 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. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details\nYou can not deactivate default features, because std is prebuilt. You need to build std yourself. Also these features are considered the default by LLVM ever since the recent upgrade to LLVM 16: This should possibly be mentioned in the Rust 1.70 release notes though?\ncc to confirm that we're fine with inheriting this change to default target features in Rust.\nMore context for this change can be found in these locations: - discussion about enabling new features in both Emscripten and LLVM. - the original LLVM patch for this - more follow-up discussion on LLVM In that sense this is an expected change, but at the same time the change was made with the expectation that most users are running on an engine that implements sign-extension. could you expand a bit more on your motivation for excluding these sign-extension instructions? I do agree, though, that this should be mentioned in the detailed release notes. It's unfortunately a bit opaque since not all users of wasm are intimately familiar with proposals and whether or not engines support them, but it's a change nonetheless worth mentioning.\nI have tried to use , still not work: Our blockchain platform has used Wasm as a virtual machine running smart contracts and has been running steadily for many years. The MVP opcodes is fully sufficient for our use case. I hope there are ways to turn off these default extension features to avoid frequent upgrades every time a new feature is introduced.\nCould you share the code used to reproduce this? These upgrades will not be frequent. This is the first time it's changed in 5 years."}
{"_id":"doc-en-rust-a8089978678632e5d6bbe082aefe9a432bfc1ad4186ebf8d6ea7f2d284d3a2f2","title":"","text":"The use case I have for wanting to build without these extensions isn't critical (servers for a game which don't support the extensions in the old version of nodejs they're running), but a way to successfully disable them to be able to build for such environments would be appreciated!\nIt would be helpful to have a reproduction of this to run to test out fixes. I tested something locally and was sufficient to disable sign extension instructions. I don't know why isn't working and that may be an LLVM bug. I can't confirm whether this works for others though without a means of reproduction.\nI just tried the following: compiled with: to make sure std being precompiled isn't causing problems, and it totally still contains the sign-ext instructions: So you are right, this is some sort of LLVM bug.\nConfirming that results in a file without the sign-ext opcodes, while does not, in my testing as well.\nwould you perhaps know more about ? I would expect that with on the function then even without sign-extension instructions wouldn't get generated, but I'm not sure.\nI wonder if this is a consequence of It looks like that might be unioning the module-level features along with the per-function features to form the effective feature set to use.\nIt can also be reproduced with:\nFWIW, the above flags did not work for me with - the resulting binary still had sign-extension opcodes (namely ) - but this served as a workaround (): Command: ^ With the wasm-opt pass, sign-extension ops were gone; without the pass, still there. From the thread above, it sounds like those flags work for some people but not for others. My use case is (was) supporting old Apple devices stuck on iOS 12 and thus Safari 12. Now past this, the binary can load, but performance is enough of a problem to suggest dropping support anyway.\nA slightly related issue is that the WebAssembly extensions used by default by the Rust compiler are not documented (besides in the change log, but new users won't look at it), I opened a specific issue for that () and just want to link it here.\nAs a heads up I've documentation about features to which I've currently got as flagged to close this issue. The documented solution for targetting MVP wasm is: which should solve the original OP of this issue."}
{"_id":"doc-en-rust-05bff122279647de7d41becf68f207dda48b40a9b7b880dcf094195b5acb1298","title":"","text":"Other solutions in this issue such as using or that in conjunction with or others don't work for one reason or another. Using the target-cpu, however, plus recompiling the standard library with , does work."}
{"_id":"doc-en-rust-7cdc79ef87272187a3994c116d49523df7131d804d1b2f1d966c795a36b75a1b","title":"","text":"Encountered an ICE when building  0.18.0 on edition 2021. I have roughly narrowed it down to the following (can probably be reduced further). Seems to be an issue with closure captures. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</detailscc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nThe code can be further simplified to: The issue seems to be around using type annotation. If a type annotation is included, the right hand side of the let statement should always be read.\nIs there a runtime check/ is MIR generated for checking if is valid? Because if that's the case then we need props2 to be caputred.\nclaim I should have a fix later tonight\nWe found another instance of this ICE that still fails with included: Found trying to migrate . Let me know if you need any more information."}
{"_id":"doc-en-rust-b0f8e8fb091eb29094beeb12734b684ad68e573ed218ab52600f0b38b92f951d","title":"","text":"Feature gate: This is a tracking issue for functions to clear the poisoned flag on and . [x] [x] Implementation: [x] Final comment 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 comment period (FCP) is always needed before stabilization. This works as follows: A library API 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 comment 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.\nHi, I read (wich got automatically closed by the way) and the PR It seems all good. What is the next step to make it in the stable API ? Can I help somehow ?\nHi, sorry if flooding but are there any updates regarding this issue?\nI think the next step is one of the rust developers needs to start the final comment period. IDK what the criteria for doing so are.\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] No concerns currently listed. Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nI was wondering whether the idea of had been considered and found that addressed it. SGTM!"}
{"_id":"doc-en-rust-617f57b4e51be51bd3a0bad9def93b56210733da1621145fc215b2dcea4bc3fb","title":"","text":":bell: This is now entering its final comment period, as per the . :bell:\nGiven the state change this method causes, I am curious about rationale behind using vs ?\nIf it took , it wouldn't be possible to unpoison a mutex shared between threads despite that being the main case where poisoning can happen.\nI just want to add that probably before stabilizing this method we should implement a lint which catches invalid patterns of using these methods since it is very easy to misuse. Or, at the very least, include information about potential footgun in documentation for these methods.\nWhat kind of lint do you exactly want? What are the patterns in question that you are worried about?\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.\nexactly the possible error outlined by Mara Bos: calling before acquiring a lock. The only way this usage is correct is when no other thread can act on mutex - either because they don't exist or because they are all blocked on something else. I believe that these situations are rare enough to flag such a pattern as at least suspicious.\nIf unpoison was a method of PoisonError or of MutexGuard instead of mutex, would it prevent such problems?\nThat was discussed here:"}
{"_id":"doc-en-rust-1adb2cbadec57d9ae462b6788373aa6f226ca0aed28e63ae6249e45c4b6ec41d","title":"","text":"I tried this code: I expected to see this happen: Instead, this happened: This is caused by different quote handling. The first (correct) command line for the spawned process (as observed by ) is: The broken one is: The command for must be in additional set of quotes, as the first and last one are stripped. It works when there are no spaces in the arguments due to the exception rule, see Stable. It worked up until nightly-2021-11-20 nightly-2021-11-21 modify labels: +regression-from-stable-to-nightly -regression-untriaged\nThis is caused by Rust now handling finding the exe to run itself (for security reasons). The fix here would be. as you say, to detect or extensions and add the extra quotes. The underlying function call here is . As the documentation says, this can only be used to run files. However, an undocumented feature of is that it will do this for us if given a or file. Previously we used to leave the argument blank and let it guess the right application from the argument. So apparently it would fill in for the application name and add plus the extra quotes to . But now that we do fill in the ourselves, it will still change to and add to but evidentially doesn't add the extra quotes. Thus we need to do this ourselves.\nThat seems reasonable; could you or someone on the Windows team submit a PR adding the requisite quoting (since quoting is hard to get right)?\nOops, sorry! I had a PR lined up but forgot to submit."}
{"_id":"doc-en-rust-c33a474aa69ac3327d136c1f1482478bc8477b593a385417dcd9564d2a3200ff","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. --Playground stable: Playground nightly: Somewhat similar to Edit: Actually, it's identical except this is with two lifetimes. Edit 2: And this one crashes stable, while the other does not. Also crashes without enabling features, and complains that However, constraining removes this error, but not the crash. Two lifetimes are required for the crash. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: Also crashes on Rust Playground with stable <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nglacier \"\"\nSeems related to\nNo longer ICEs since"}
{"_id":"doc-en-rust-bf243b35319b13f45336064ff6898dec90db392f7fb916bc9cefbe9e805db944","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 --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nmodify labels to +A-inline-assembly +F-asm +requires-nightly +O-riscv\nInterestingly this does not reproduce when change register names to x86 ones; a error will be generated correctly.\nI think I've located the issue. claim\nclaim"}
{"_id":"doc-en-rust-7a112e0f3d186a331262c1028dd253f8836530dae85558820ee2b209db2489fd","title":"","text":"Would you like to fix this issue? I'm dealing with a case where I have to send a byte array buffer to a destructive function multiple times. This function requires the buffer to start with an initialization sequence that I have to set. I want to be able to efficiently reset the header bytes but the size of the initialization sequence is less than the total buffer and so I hit the error. The real question is, why is this required? Here's the current code: In theory, if is big enough to hold shouldn't that be enough? The adjusted call should be this then: I think the same should be done for clonefromslice.\nThe discussion of that decision is in\nHoly bikeshed Batman! It’s impossible to find in all those comments! Thanks for pointing me there. It does seem from the first 30 or so posts that it was intentionally meant to fill the destination. If it does stick around, I do think the size checking should be done a little smarter.\nIsn't fine? Personally, I find a bunch of value in the explicitness of requiring equal lengths since slicing to get the other three possible behaviours is so easy.\nThat's not a bad argument. Maybe we can adjust this to suggest that in the error message? I wouldn't have found that on my own.\nsome examples to the docs of using subslices with these methods. I don't know what the libs policy is on adding guidance to panics -- it does feel like one wouldn't want a long explanatory string built into one's binary in release mode, at least...\nAgreed. In general, the longer the message the less likely people are going to read it clearly. I also believe not just stating the problem, but also offering a suggestion. “Destination and source slices have different lengths. Try sub-slicing the longer of the two.” This offers a jumping off point for Googling and reminds those (like me) that sub-slicing is a thing.\nI'm personally against lengthening panic messages to suggest fixes, rather I'd expect someone to ask a question about this on StackOverflow or a similar platform eventually which would then get indexed by search engines. I'm going to mark this as an easy documentation issue; we can update documentation to note that subslicing is likely what users want to fix the panic in the panic section or the main section."}
{"_id":"doc-en-rust-32b862f708bea542bd1106723edfcacfc31aee18b6ae8376fa476b7ca2c65bbc","title":"","text":"I'm happy to mentor anyone who wants to fix this issue! Here's how: The relevant documentation lives here: This should be extended to describe how to use slicing to make the lengths the same. Something like the example, but with text pointing out how without the slice, it would panic, so slicing to the same length would make the guarantee. I'm happy to answer any more questions about how to accomplish this!\nPR:"}
{"_id":"doc-en-rust-a4b53c3645bc265e33649832a59ad749f3726a8fed73b58b68318620ba8777f9","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. --After adding to , I get the ICE. The resulting : The full project: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --\nLooks like another label: +T-types +WG-trait-system-refactor +regression-from-stable-to-nightly\nStable passes, beta passes. Nightly passes with either or Discovered with It does sporadically succeed, thus needing to clean and rerun the build to make sure. Either something is up with or it only barely exercises these conditions in the parallel frontend, even after cleaning and running the build 100 times. Meanwhile, fails something like ~50% of the time on my machine.\nstable passes obviously, as -Zthreads this is a unstable nightly-only flag?\nHm, not actually obvious given that works, though I suppose that does mean it isn't a regression per se. :^)\noh I thought you knew by now that this is the forbidden env flag that should only ever be used for bootstrapping and nothing else and we should not even tell users about it. If you set the flag, your \"stable\" will also eat nightly-only features, but why would that make a \"to-stable\" regression if you explicitly tell the compiler \"please act like you are NOT a stable release\"? I don't think it make sense to backport fixes for untable nightly features into stable lol\nwho mentioned backports?\nThe label is used to gather regressions between release channels, which are then discussed whether they are backport-worthy or not. Is that not how the label is used?\nI don't really think regression-from-stable-to-nightly nor regression-from-stable-to-stable are used for that at all? Probably regression-from-stable-to-beta is?"}
{"_id":"doc-en-rust-91a511678b8bd37afda281060b509c61400313307c6b72d35c98ba6aba169bdd","title":"","text":"Pretty much what the title says, I've narrowed it down to and today's nightly with the following: I've attached some backtraces.\nprobably duplicate of but made more prevalent by next solver\nIs it possible to provide a link to or a snippet of a reproducer? I know it probably happens to various crates, but it still would be nice to have something that reproduces.\nSee for an attached repro.\nThe repro case is basically the same as , but with other crates mentioned in the ICE logs from the issue comment."}
{"_id":"doc-en-rust-32ff646f69c4d3591634de303f58948eacb7c8a704ef0a69b4d876dbb32ef910","title":"","text":"Compile with latest Nightly got ICE like below: when compiling in code OS: x86_64-apple-darwin\ncc\nWyvern, could you provide some sort of reproducer? A link to some commit in some repository or better yet a smaller stripped down version of it?\nCan you provide an example which triggers this behavior?\nI'm not sure which commit/PR of lead to this crash, sometimes it compiled successfully, sometimes it not. Add this info to original post, hope to help investigation.\nare you running with greater than 1? The cache is broken when used with more than 1 thread (which we should fix)\nSorry, I wasn't clear. I meant a link to your project (the project you are trying to compile) if publicly accessible / not proprietary.\nI can hit plenty of these while fuzzing with -Zthreads so yeah its probably that.\nYeah, I think was the culprit. Comment out this option crashes disappears.\nthe easiest fix to rustc is to just disable this assert when we're using more than 1 thread. I've only it for debugging purposes to detect cases where we unnecessarily recompute cache entries\njust hit this while trying to bootstrap with Zthreads :sweat_smile:\ncc as this also showed up in your ci test run ^^\nWhen I just disable this assert, all relevant UI tests passed with no other bugs or ICE\nsamle code that triggers this in around 5 of 6 cases with -Zthreads=16"}
{"_id":"doc-en-rust-759a84b7979b9c922af097200dfb74cc0070c4252ed9e97e4a1ef4043f121338","title":"","text":"the closure being passed into in BTreeMap and VecMap's benches has a trailing semi-colon making the return value , and thus making the entire operation a no-op. Removing the semi-colon causes lifetime conflict issues. CC\nI have a branch that just gives up and replaces these with macros. This results in clearer and more concise code like . Confirmed produces sane results in benchmark output. Hope to submit something tomorrow."}
{"_id":"doc-en-rust-9228dc5207e3ed50f784ce414a3cd7ce9d6a2830876e108d110683b18872b1a4","title":"","text":"When a shared reference is assign, the gluedrop function is called with the old value before the gluetake function is called with the newvalue. With an assignment like \"self.o = self.o;\" the generated program will core. Of course, it's a silly example. All other examples I tried make a gluetake before calling the assignment (for example if you call a function with the argument \"self.o\" which will be then assigned) so you should never have this case in a real program. Maybe it doesn't need to be fixed as it shouldn't happen with a real program.\nA simpler example: That segfaults for me. This should definitely be fixed!\nHm. At some point we had a test for this because I was quite careful to make this work correctly. Wonder when it broke.\nStill segfaults as of\nNot 0.6\nStill segfaults as of . Nominating for milestone 5, production-ready\naccepted for production-ready milestone\nStill crashing\nStill crashing with\naccepted for P-high\nWorking on this\nThis no longer reproduces (with NIko's test case). I also tried with a managed pointer because apparently glue take/drop is only used for ref counting now and could not repro that way either. I tried to create a testcase as described in the first comment, but TBH I'm not really sure what was required. I tried a few things nothing crashed. I also examined the llvm ir and the 'problem' is that we never create these drop before take patterns. Anyone got an idea for how else this bug could be repro'ed (I really don't understand the glue stuff, so I might be missing something obvious)? Otherwise I suggest the bug should be closed.\nI'm not sure if we have a test for this already. Perhaps there's one that was marked as ignored.\nWith a test case checked in, it looks like this can be closed (unless there's another subtler bug going on here).\nI made a big effort to get this right as part of -- and totally forgot to write tests!"}
{"_id":"doc-en-rust-239333447c8027eebf15ee1214252fbc448fc14c8fef0b439046d92e57a398a0","title":"","text":"has to but the PR made it only into Rust 1.42.0. Thus the version number should be adjusted. cc\nWe would be happy to accept a PR for this. I suppose it's a trivial enough fix that I would even be willing to backport it (so we avoid 1.42 indicating incorrectly), but only if we get it in quickly enough. cc re:backport, since you're doing release\nI won't do it but it should be easy enough.\nI just made a PR for updating this; this is my first contribution to the project (please let me know if I did the process right). Hope that helps!\nI just noticed this and saw a PR already existed, amazing! to a backport."}
{"_id":"doc-en-rust-dcc728e446ee8b60b010874c87905a4130754814d24e752352c082ee14ed7a41","title":"","text":"Currently, the compiler is allowed to inline naked functions if it wants to. For a normal function, inlining is fine because the compiler can remove the function prologue/epilogue and the remaining will behave as expected. However for naked functions, the developer provides the prologue/epilogue and those aren't removed by the compiler. This almost surely will result in incorrect behavior. Accordingly I think it would make sense for the compiler to not inline naked functions unless the developer explicitly opted-in.\nIn the other thread, alistair23 found that\nYes, functions should imply ."}
{"_id":"doc-en-rust-0215e07468d4a42f6f74d9d2010a220c0541027818e1a60c21ebcb43966e1c60","title":"","text":"https://crater- modify labels: +regression-from-stable-to-beta I-ICE\nsearched nightlies: from nightly-2020-09-24 to nightly-2020-12-11 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: aarch64-unknown-linux-gnu Reproduce with: </details\ncc -- seems like this one might be an actual bug\nSmall case that I think shows this issue, it incorrectly fails to compile on beta/nightly.\nN.B. I haven't gotten it to ICE, so I can't add it to the"}
{"_id":"doc-en-rust-4c1df422d94ba6c7a85a40b88f5eb3ead3d964f5784db58c14b80d1465e90217","title":"","text":"Rustbuild now prints which is very not helpful.\nI've hit this one too: When there's a stale in Rust's root directory, bootstrap reads paths from there and tries to convert them into windows format using (which it, of course, can't find since we are not running in msys shell). The error message comes from in buildhelper (called from )."}
{"_id":"doc-en-rust-24705db411c7f2b3dfb2ca7beaca10ca2882f98ee0acccad777fb0b33303bb59","title":"","text":"I tried this code: I expected to see this happen: Print the content of the $123 environment variable Instead, this happened: It literally prints $123 : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nIt is the shell that resolves environment variables. You're not using a shell here, just directly executing a command. This is behaving as expected.\nIndeed, this is the expected behavior. This can be circumvented by actually using a shell, e.g. on POSIX:\nI did a quick check on the doc for Note that the argument is not passed through a shell, but given literally to the program. This means that shell syntax like quotes, escaped characters, word splitting, glob patterns, substitution, etc. have no effect. I guess we can expand \"substitution\" into \"variable substitution\" to make it more clear.\nso is this just a documentation change? claim"}
{"_id":"doc-en-rust-01da442dcf40cc612b1e688c09365d481b1a0313d05d1b0ac40c1dfb588ab213","title":"","text":"Feature gate: This is a tracking issue for . This feature adds methods to / to gain access to the contained value, by unwrapping if there is exactly one reference, or cloning otherwise. It is equivalent to cloning the inner value, but saves the clone operation if the caller has the only reference to the rc'd value. [x] Implementation: [ ] Final comment period (FCP) [ ] Stabilization PRThere seems to be consensus that the current name is good.\nApologies if this is the wrong place for this comment, feel free to delete. Is there a technical reason why is an associated function and not a method? If I have , I cannot call , but have to resort to which feels unwieldy.\nit's because / are 'wrapper types' that implement . A lot of the methods are implemented as associated functions so they don't clash with method names on the . This makes it easier to change between different wrapper types like / etc without suddenly getting a name clash. Apologies if I'm using the wrong terminology but that's the gist of it.\nThat makes sense. Thanks for the explanation :)\nsounds like a bad name to me: has a connotation of potentially panicking code in Rust. The other suggested names in all sound better to me. (Couldn't comment on the thread in IRLO as it has been closed.)\nThere is precedence for this pattern: for example.\nTrue, I overlooked it.\nI think this name is good, and it's easy for me to understand what it means. I'm really looking forward for this to be fcped and stabilized.\nAt $work we've been using the exact same implementation as the one used in nightly (), it works perfectly well\nWhile I like the proposal very much (for it's convenience), I feel like I want to point out something that might be interesting as well in the future and is related: It's not possible to use where . In this case we have an , which is . However this is a conversion that is also very useful. It would be intersting to go from to . The other way is already possible, but this way is currently not possible, however there are sometimes cases where the count is known and converting back to a Box would be very useful. Consider wanting to remove an element from an for example."}
{"_id":"doc-en-rust-1be340b48070cc19c32506554a7538add415aae8647681f1eefa27dcfb02ff18","title":"","text":"The current way to do this is to clone the vec, remove an element and make a new Rc, even when an Rc is empty. I understand that there would need to be something like a first, but I just wanted to bring it up, so it's clear that there's potentially more things that could \"unwrap\" from an Rc.\nTry this: The code above will copy vector if needed. (I didn't test the code)\nYes, good point, thanks for bringing it up. However a Vec is unfortunately another layer of indirection. Typically I have something like .\nIs there something that still needs to be done before this can go to FCP? I just came across the need for this and noticed that the comments seem positive with confirmation that it works at $work for at least one commenter above, so am wondering what if anything is preventing it moving forward?\nPinging here for input. There seems to be consensus on stabilizing this. Can anyone start an FCP? I'd be happy to work on a stabilization PR (with some guidance)\nfcp merge Both of these are already expressible on stable using the following incantation, which is exactly the standard library's implementation too: . The rationale for a dedicated method is that \"I need a \" is a common enough use case that it's worthwhile to have one easy function prominently available in the type's API doing the thing you most likely want to do in that scenario.\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.\nand others: is related\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.\nI believe that can check off the stabilization?\nAnd update the documentation as this seems to have been stabilized."}
{"_id":"doc-en-rust-f484ca7aaf6a480cb96965a18ba0c5ac66befdf720271682cc024f23bef9e60a","title":"","text":"I am getting this:\nArc<strstores the string inline on the heap together with the strongcount and weak_count of the Arc. This means it has a different in-memory representation than Box<strand thus can't be converted into a Box<strwithout copying the contents. A Box<strto Arc<strconversion also copies the string contents into the Arc allocation.\nI understand that. But moving elements from an Rc to a Vec is different from cloning. The opposite direction is already possible. This means that you can write , but not . I understand that moving is different from . This would probably need to be named something like Vec::frommovedrcorclone`.\nGitHub deleted all my angle brackets. I was specifically talking about converting between string types because there's no difference between moving and cloning characters."}
{"_id":"doc-en-rust-38b6b13ea6851768539ce3c9c1bcde9feef28b6f18a0fc0dd207a4e13a38fd07","title":"","text":"seems to result in a call to in the drop glue (and no allocates), which results in a crash. Just doing works, as do non-empty input arrays.\ncc\ncc should this have been fixed by ? Or did cause a regression?\nit appears to have been fixed, this example doesn't crash in my local branch (assuming it's not something else I've done since).\nI have 2 tests based on example, one using the syntax and one using . Interestingly, using causes a compile time error: Shouldn't they both behave similar in this case?\ntest with doesn't compile because the argument to that function must be . However, the code does compile and run successfully with the syntax, so a PR containing src/test/run-pass/issue- from should close this issue."}
{"_id":"doc-en-rust-a5d92562d0e782d792a058e69eb1d28ef8c4a5d1b09f20453baf4fb79113f0c5","title":"","text":"Steps to replicate: two files and in the same directory with the following content: both files the following error I note that the looks quite suspicious, since there are fewer than bytes in the source text. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nFull trace:\nthere's a single in . You can just return if the output of is .\nAre you sure that's correct? I was looking at the invalid that begins in the source file and ends in a separate virtual file. It seems like it should always be an error to record a into the such that is false. And perhaps if this were corrected, the would succeed.\nThat is a correct assessment, but the current state is that whenever we involve macros we can easily generate incorrect s. We shouldn't, but fixing that underlying issue is much harder than just dealing with the fallout. We have some efforts to clean up the situation around (and its gotten much better lately), but there are cases like for suggestions where we are assembling new spans from different sources and checking at generation time that they are valid would become too verbose and hide the actual logic. For now, I would just fix the stray and fix the ICE so that we can buy time.\nA compiler built from that pull request no longer exhibits an ICE on this example.\nThanks for fixing it!"}
{"_id":"doc-en-rust-6cf3c2bb3c08a38bafff3532db72ea1908c7190bb562a2249ecc7c70a784b1e0","title":"","text":"Tested on nightly and stable. The second diagnostic is strange. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nlabel +A-diagnostics S-has-mvce\nclaim\nany idea why rustbot ignored me?\nJust guessing, the missing + for S-has-mcve maybe?\nOops, this should'nt've been closed."}
{"_id":"doc-en-rust-b20ea525c93f7e4cdea54bce8e0003659c0714e32468e88f5106f8ee9d40b9cc","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: code compiles and execute Instead, this happened: compilation fails with It most recently worked on: and <!-- Provide the version you are using that has the regression. --: <!-- Did the compiler crash? If so, please provide a backtrace. --<!-- 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 --used by . I suspect (but did not confirm) might be the cause of the breakage as it is a recent change on that area. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc\nThe code posted has a missing delimiter.\noops, fixed\nclaim\nWG-prioritization assigning priority (). label -I-prioritize +P-high"}
{"_id":"doc-en-rust-099e817a0e38b98fb2e1c643ce49d6118ae26651c9c06c1d15c2983f1b67d09e","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. --Take this simple crate: If I try to gather code coverage for , I end up with the first line mysteriously duplicated as a covered region: (I'm using for convenience, but the same thing happens when I use and process the coverage data manually with and .) Note that in the report produced by , the first line of the file appears twice. It is marked as having executed once, even though it is a comment. Instead, the line should only appear once, and its execution count (if any) should be the execution count of the actual code on that line. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --<!-- Include a backtrace in the code block by setting in your environment. E.g. . --<!-- <details<summaryBacktrace</summary<p</p</details--\nI did some initial investigation, and discovered a few things: The coverage mapping that embeds in the test binary contains entries for two different functions named . One is the actual that appears in the file, and the other is the that is injected by the test harness. The mapping for the injected function spans from (1,0) to (1,1). Coverage mapping regions use 1-based line numbers and column numbers, so a column number of 0 should be impossible. This unexpected column number confuses the processing code in , and results in line 1 being duplicated in the output. : There are special circumstances where it's legal for a region to have 0 for its start column and its end column, but that isn't what's happening here.\nThe origin of the bogus (1,0) to (1,1) region seems to be: The test harness entry point is created with a dummy span: When that dummy span is converted into a region, its 0-based start is decremented in an attempt to make the region non-empty. This decrement overflows to , and a subsequent increment (to make it 1-based) overflows back to 0.\nMy first thought was to sidestep the whole issue by adding to the test harness's injected ."}
{"_id":"doc-en-rust-3393f74b9118d3aef2983eba7da6e5a4db4e3617ee745177ac2e33e42f1f22ce","title":"","text":"However, I couldn’t get that to work, because is unstable and can't necessarily be used by the crate it is being injected into. So I think the fix will involve having the instrumentor detect and skip code with dummy spans.\nlabel +A-code-coverage\nfixes the overflow, which gets rid of the duplicate line. However, the instrumentor still ends up emitting an empty region from (1,1) to (1,1) for the test harness's , so I'd still like to find a way to avoid instrumenting that function.\nI think the empty region now confusing the reporter in more subtle ways, because now I see weird stuff like this: It makes sense that line 1 is “covered” (via the injected ), but it's strange that lines 2 and 3 also have non-zero counts.\nIt looks like does have special handling for empty regions, but it doesn't properly anticipate the first region being empty, and ends up in a slightly confused state."}
{"_id":"doc-en-rust-4477c219ee577f821f0b01cf8a30dfe62e9f92f5f6f150df61273654376f0832","title":"","text":"I've got a Rust minimal repro code (a.rs), its mir output (a.mir), its x86 codegen output () and its gnu-x32 codegen output () All these files are in this this . Currently, fails, saying \"llvm error cannot emit physreg copy instruction\". I don't understand llvm ir at all myself, but i tried commenting out L309, L311 & L314 out (all accessing a special 'variable?' called 'unsizedtmp') and it passes, then i uncomment L309 and llc fails again. This issue is blocking . Maybe or someone else who's familiar with could have a look or give me a hint about this?\nForgot to mention: I generated these files with to make the files shorter, but that's unimportant detail, i guess.\nIf you haven't yet, you might try using  to minimize the ll to a smaller reproducer.\nUsing bugpoint, i got this(I used llvm-dis to convert it to text):\nLooks like it can't deal with the \"probe-stack\" attribute: removing that makes it work. My guess is the probe stack code doesn't do well with gnux32 targets which is 64bit but has 32bit pointers. The LLVM debug log re: why it fails:\nSpeaking of stack probing, I guess might know more about this?\nTo unblock things, I think it is reasonable to delete line in file while we investigate the issue. Stack probes are x86-only feature that is disabled on other architectures anyway.\nI guess LLVM needs a upstream fix for stack probing on x32 (it probably emits code using 64-bit registers). We may also want a x32 specific stack probe function in\nI've pushed as the temporary workaround.\nFiled: LLVM: compiler-builtins:\nFixed upstream by I believe a separate stack probing function for x32 is not necessary, the one for x86_64 should work fine.\nThe LLVM fix is now in nightly, so we can try re-enabling this again."}
{"_id":"doc-en-rust-aabd150f83489b1935f382030f552306221c0bba742003aab84895c06fe936b1","title":"","text":"Good 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: uses the flag with  (mentioned above, in 2.6.23) uses with  ( in 2.6.24, there is also the mention of a bug occuring on \"some linux kernel at some point\") uses  to atomically set the flag on the pipe fds ( in 2.6.27) uses with  ( in 2.6.27) uses  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. Originally posted by in\nKernel updated in .\nAs noted, needs a much newer kernel 4.5, so we'll still need that fallback. But all the stuff should be ok to assume available now.\nThe new minimal version is 2.6.27 from what I can see, so \"Socket::accept uses accept4(2) to permit use of SOCK_CLOEXEC\" still needs a fallback, right?\nThe builder is using 2.6.32 headers, so I would call that our new minimum.\nAh right; I am actually not sure where I got the 27 from...\nThe title of suggested 2.6.27, but we went a little higher to match the actual distros in use.\nI know this is ancient history, but do you recall the problem with ? You introduced that comment about \"some kernel\" in , and you were the last to update it in . If the problem kernels were before 2.6.32, then I'd like to clean that up now.\nJust digging in kernel history, I did find one hiccup in , but that bug was introduced and resolved during the 3.7 development cycle, not in a release.\nIIRC we just mirrored what musl did at the time, which looks like it : Looks like the original mailing list thread is gone and there's no comments in the musl source, and I don't recall what happened here. I suspect it would be safe to remove those workarounds and just assume works one the first try until someone says differently."}
{"_id":"doc-en-rust-c6674e20ed90b7f60d5a3d2c25149d2f37743c5a187ef4fdd77b1627c50694d6","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: When a user called with an annotation, it's helpful to suggest too. <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nIf it's ok, I would like to give a shot. If you plan to work on it, please go ahead.\nIt's yours :)\nclaim\nHi, I would like to ask a question... I'm reading the code now and am thinking of extending the error messages by adding to . My plan is that start adding some fields (like ty::TraitRef) to and dbg! the output to get the value of trait information like for a new error message. Is my approach out of line or is there a better approach for that.\nYou don't have to hold information of in because we can get the info on-demand by the combination of and . Say you'd add a method of , the code will be something like this: For getting the name of the trait in question, or will be handy for you.\nI appreciate your answer.\nare you still working on this? :)"}
{"_id":"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-60121fc379df37aebbc4066801024ecdb08b92b61e49f5acda21d72ec5531588","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. --: : &lt;!-- Include a backtrace in the code block by setting in your environment. E.g. . --&lt;details&lt;summary&lt;strongBacktrace&lt;/strong&lt;/summary&lt;p&lt;/p&lt;/details&lt;!-- TRIAGEBOTSTART --&lt;!-- TRIAGEBOTASSIGNSTART --&lt;!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --&lt;!-- TRIAGEBOTASSIGNEND --&lt;!-- TRIAGEBOTEND --\nThe real error isn't the unemitted diagnostic, it's the unwrap. The unemitted diagnostic only happens bc this unwrap occurs during diagnostics code, I think.\ncc I think this might be and we try to suggest .clone() which is not available for the type though?\nIf you add ... to the example you no longer ICE and just hit the normalerror[E0382]: use of moved value: 'x' `\nclaim\nPlease use this minimized repro:\n\nEvery time I think \"surely this will be fine\", it bites me in the read as sure as the sun coming up.\nAre we fixing ICEs? Not so sure we should bother...\nThis one was particularly easy to fix () and probably shouldn't've have been an in the first place (unwraps in diagnostics code are generally a code smell, since they should fail gracefully in strange situations) -- but I generally agree, had this fix required some large refactoring or implemented extra checks on a performance-sensitive path, then I think this should've been closed w/ a wontfix."}
{"_id":"doc-en-rust-e6a6c868c4a82b9d69b09a43e032398fcfee12d6a72ad15fe0e145f111e0caa3","title":"","text":"Previously: Now: <!-- Thank you for finding an Internal 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\nInlining exposes a use of unnormalized local in a call terminator (not sure if this is more of an issue with inlining or a validator): Note: revision annotation doesn't work in an auxiliary file (so it isn't tested on CI with mir-opt-level=2). modify labels: +A-mir-opt-inlining\nThis ICEs again because the fix was reverted Can someone reopen please?\nDue to this new requires to trigger. <details<summaryICE:</summary</details\n(FWIW can also trigger this: )\nfixes this for and , but it still ICEs with on its own or with mir-opt-level 1/2 cc"}
{"_id":"doc-en-rust-1e91a33f7369d84f0bc42974a03df193d853988de2edb10da26581d11b8a406f","title":"","text":"I tried code very similar to this: and it produces some type of type checking error when uncommenting the line beginning with . : Backtrace:\nThe error is likely due to the fact that the trait bounds on don't include for , though the compiler/type checker crashing is still likely a bug.\nThat code was introduced in , cc Submitted as a quick fix.\nI can't get it to work in the same crate, just with two crates, where the first one depends on the other: modify labels: -E-needs-mcve\nThanks I included a test in the PR."}
{"_id":"doc-en-rust-de320901aad795d716eb5c528af4a538700692853026c473b4d9693f3435b1f4","title":"","text":"Rust should pass more structs in registers. Consider these examples: ideally, both functions would execute entirely in registers and wouldn't touch memory: Rust, as of a recent 1.2.0-dev nightly, is unable to pass either of these in registers (see LLVM IR and ASM below). It would be pretty safe to pass and return small structs (ones that fit into <=2 registers) in registers, and is likely to improve performance on average. This is what the System V ABI does. It would also be nice to exploit Rust's control over aliasing, and where possible also promote reference arguments to registers, i.e. put the values in registers for the following functions: In the case, this would mean passing two values in registers as function parameters, and returning two values in registers as the return values (ideally we'd arrange for the parameter registers to match the return registers). Uniqueness of makes this optimization valid, although we may have to give up on this optimization in cases such as when there are raw pointers present. Here's a more realistic example where I've wanted Rust to do this: This function is too large to justify inlining. I'd like the begin and end pointers of to be kept in registers across the function call. Probably not surprising to the compiler team, but for completeness here is the LLVM IR of the above snippets, as of today's Rust (1.2.0-dev), compiled in release mode / opt-level=3: and here is the ASM:\nFor fat pointers this has been fixed in Am 22.06.2015 07:58 schrieb \"Reiner Pope\"\nOn etc. this is currently impossible because the address of references is significant (you can e.g. print it with ).\n- yes, the ability to take addresses prevents doing this for all functions. But you could see doing this as an optimization: make the compiler check whether a function uses the address of a reference, and if not then change its calling convention. The compiler can use the worker/wrapper technique (as in GHC) to support call sites which aren't aware of this change in calling convention, by splitting the function into two:\nDon't do this. You will break FastISel. Fix LLVM if it's not doing the optimizations you want.\nwhat exactly would break FastISel?"}
{"_id":"doc-en-rust-61be01efc6121e3de8149e3f8b156621a841983fa218c7015c899d918d5e889d","title":"","text":"Pretty sure that since work on niche-filling optimisation, and use a pair of registers for the argument and the return value, respectively. Cc\ndidn't solve this?\nYes, this appears to be fixed. The following Rust code (): generates and\nAh no, I see that this issue also suggests: We don't do that yet: . FWIW Maybe it is worth to split this issue into two. One part has been closed already AFAICT. The other part (passing as a register containing a ) is... a suggestion at most. This issue does not suggest how to do this. already raised the issue that this breaks if the address is inspected. It probably needs to handle writes through (e.g. due to ) and somehow as well, etc. So I'm skeptic that this can work.\nHere's another slightly more complex example, where ABI seems to be more efficient than :\nA related thread:\nis this fixed? Linked code is still bigger on Rust 1.48.\nmy example is fixed, the return value is no longer via stack: The difference is that rust abi version now uses a vectorized add, which seems like a win?\nHi all. I've traced back the cause of 'P-high' issue to two pulls that relate to this issue, namely and . Basically, these commits break auto-vectorization post Rust version 1.48 in a way that is not easily worked around. In short, if we take: 47 yields an efficient: 48 yields an awkward: 50 yields an even more awkward cascade effect: There are other examples in . My overly simplistic analysis, I'm no expert, is . In summary, if I rebuild Rust with the above pulls neutered, auto-vectorization appears to return to normal, as per 1.47."}
{"_id":"doc-en-rust-27abf7dffdd9fb3420783921a65ebbfb4054467a1c3c0f7240038bbba2872f0e","title":"","text":"I expected just a compiler error . Compiler panicked: Meta\nThis is fixed in the beta version (1.30)."}
{"_id":"doc-en-rust-afa01b1e4a6f7a1fc98bc53710b50fb4a7badf9201d0c207379809b43c80a6cc","title":"","text":"This lets you get a mutable reference to an immutable value under a specific case. Code: From what I can tell, the tuple and at least two depths of Enums are necessary, along with an on the right side. There's probably other variations, but that seems to work well enough. Expected output would be a compile error, instead output is This works on both stable and nightly\nwould fix this as well?\nFixed by . Off: I wonder why we can't ship nll yet. It would solve so many issues right now, because of the match ergonomics sigh Match ergonomics produces roughly 10% of all errors/unsoundness/ICEs atm (at least it feels like this)\nYes correctly fixed this issue."}
{"_id":"doc-en-rust-c962be447d92386b66463298067162c69ff532b13ba8529ac102b5acff31bf86","title":"","text":"Sometimes when things go really wrong the compiler emits a ton of error messages. This can actually take a while to render them all. And since somewhat recently, hitting Ctrl-C no longer interrupts that, I get a thousand error messages displayed after Ctrl-C. I suspect this may have to do with The Ctrl-C handler does nothing at all on the first Ctrl-C unless the compiler is in the middle of const-eval. Cc\nDo you have a reproducer? I have not run into this myself. The implementation should also ensure that the compiler exits promptly if you hit ctrl+c again. Does it?\nif stuff keeps going on ctrl+c, sometimes suspending the process (ctrl+z) and then killing the terminal does the trick somehow :sweat_smile:\nUnfortunately no, I encountered this during some rustc hacking where I ended up getting well over 1k error messages in the standard library build and that turned out to be hard to cancel. I thought I had tried that, but I am not entirely sure.\nIs it possible the shell is part of the problem? If, by the time you hit ctrl-c, it's working through a large amount of output it still has buffered then it might be awhile before you see a response.\nIt's possible, sure -- but usually it reacts to Ctrl-C immediately even when there's tons of output.\nHave you tried reverting to check if that fixes it?\nNo. At the time I was busy getting a PR done and now I don't have a reproducing example any more.\nonly checks for ctrl-c during const eval, so if no const eval runs for an extended period of time, the ctrl-c will be silently ignored. This is not the only problem with that PR. It also caused , and shows the \"compilation was interrupted\" error after the prompt is already drawn by bash.\nis there a good way to make rustc loop endlessly without ever touching const eval? maybe via the trait solver? :thinking: it would help for debugging this.\nYeah, just take any issue (none are anyway). I can reproduce this issue with for example: nightly-2024-03-26 (before ): Exits after a single ^C nightly-2024-03-27 (after ): Requires ^C^C to exit bjorn3's analysis checks out.\ncool!"}
{"_id":"doc-en-rust-0deeca6e96f0956156d33fe5020552fadd682a536e7fc2c17a0d2caf9ddc8b2a","title":"","text":"I wasn't sure how much of the compiler's code flowed through const-eval, is why I asked.\nAnother case where this is observed: IMO we should revert or at least make the signal handler run after a short timeout.\nI'll post a PR that adds a timeout later today, but by all means if you feel strongly just put up a PR. The initial handler here was just through the normal PR process, there's no reason to be more cautious on reverting or modifying it."}
{"_id":"doc-en-rust-7985c267ad2f3f852db605f6024dae811735b7f2e909df00229c2dacf6c3338a","title":"","text":"Internal compiler error when missing bound on struct. Reproducible on stable/beta/nightly on . Also, not sure if it already has it's own issue, but is causing an illegal instruction error when you run it with on this code as well, which is also reproducible on playground if you turn the backtrace setting on. I tried this code: () I expected to see this happen: Instead, this happened: rustc versions (from playground): <details<summaryBacktrace (note the SIGILL at the end)</summary<p</p</details\ncc\ntriage: P-high, removing nomination label (has PR)."}
{"_id":"doc-en-rust-b2dc0285c0536e048e73e3a689515b8b39e8cb2e21cd9e1b0837ae8ee6013412","title":"","text":"In an example like we report the following error: This is part of the macro future-proofing code but it is an unnecessary limitation. For fragments that represent at most one token tree (, , , possibly others) there is no concern at all about being following by sequence repetition. This turns out to be a really big limitation in practice, since making macros that work over a generic sequence of token trees effectively allows for arbitrary parsing. cc\ntriage: P-medium\nI'd be happy to mentor this, if I don't fix it first.\ntriage: P-medium\ncc\nI-ICE?\nCurious why this was closed, looks like it's blocking lispy-rust.\nIt was fixed by ; do you still see this issue present in nightly?"}
{"_id":"doc-en-rust-740e0124fe7b9fb360f4e9638fbe9ccc902825c50c3d2e1b17fb8758a8ca2f54","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. --%5D%0D%0Apub%20trait%20IceIce%3CT%3E%0D%0Awhere%0D%0A%20%20%20%20for%3C'a%3E%20T%3A%20'a%2C%0D%0A%7B%0D%0A%20%20%20%20type%20Ice%3C'v%3E%3A%20IntoIterator%3CItem%20%3D%20%26'v%20T%3E%3B%0D%0A%7D%0D%0A%0D%0Afn%20main()%20%7B%7D%0D%0A) <!-- If 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 ICE happens on , and : : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nMaybe related to\nBisection: bash cargo bisect-rustc --regress ice --test-dir=foo `\nLooks like\nICE happens on stable and also even without the line so no requires-nightly. label regression-from-stable-to-stable, A-traits\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-low"}
{"_id":"doc-en-rust-85e792ebf331e198de4bd085164cbdeced03fc8981ae0c9725edadf4a3d29c6d","title":"","text":"Failure happens in the crate: This probably has to do with how we're calling the \"custom resume\" function, unsure what's going on.\nDuplicate of\nIndeed!"}
{"_id":"doc-en-rust-4142730d7ccb19d319f6d7ad01edfb94edb723fcbc117571ebf399fd6ff47095","title":"","text":"I haven't gotten it to error without nightly features, so I believe it has to do with the generated enum for the Generator. : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</detailsAs an aside, if one gets rid of the , this fails (kind of expected, though the error message could be improved) with\nNo longer ICEs since"}
{"_id":"doc-en-rust-61ae42eb84e53959cf65c1aa95374806ebdcd9401bb058e30a16c644d381bd04","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!\nThis might be due to no longer builds: ` We need a new version I think. The last published version of is 5 months old already :thinking: Can you please check why there are no new versions being published?\nTIL scheduled GitHub Action Workflows apparently require regular activity in the repository to keep going :eyes:\nI didn't realize anyone was still using those crates so I disabled the action, I believe it was broken anyway. Does rustfmt and/or other crates still use those packages? If so I can try to find time to restart the action.\nRacer those crates. And RLS . So without those crates compiling racer with the latest nightly isn't possible, which makes compiling RLS impossible and therefore blocks the sync of RLS back to rust-lang/rust.\nWould it maybe be an option to make racer depend on to compile instead of publishing AP crates?\nWe stopped using them in rustfmt a while ago and I can't imagine a scenario where we'd switch back. Agreed on racer, which AIUI is the last true direct consumer of those crates. However, it's also in and those crates only get bumped in racer when a racer consumer needs them to be bumped.\nAh ok. In that case if this is purely for something in maintenance mode I think my own personal tenure in maintaining these crates is over with, so I would prefer to hand over the reins to someone else. Would someone be willing to volunteer to take over these crates?\nlet's sync up on #t-infra on Zulip -- I think it makes sense to move these crates into infra control/publication.\nLet's wait if Racer can move over to rustc-dev racer-rust/racer. If so, there shouldn't be a need to keep maintaining rustc-ap crates at all. Looking at the dependents on , there really is only , the crates themselves and (which by now uses ).\nhas some relevant considerations as well."}
{"_id":"doc-en-rust-a04cedb3845472cf468557dd248e7c41b462fa547c486446d30eb621ab58e9b4","title":"","text":"One way or another I think the AP crates need to be accounted for as per the accepted RFC, though it certainly would be a simpler story if they no longer need to be updated/published\nHappy to coordinate as necessary, just let me know!\nOver a month now. Is this gonna be fixed?\nit's blocked on"}
{"_id":"doc-en-rust-c3ee0a934c5db0c551dfaac0b2304d07e57dd89e5cf30083447dc6b8fb99ea21","title":"","text":"Reading over the Ownership section in TRPL and came across the example As a newbie, this was very confusing. I believe the situation could be explained by simply adding another line. I'm not sure if this is the best way to do this.\nThis sounds like a great fix to me, (although I would add the to the signature for clarity). PR welcome! :smile:\nI've been waiting for input on my PR for several days. Still have no response. The ? didn't compile, and so I'm not sure what to change it to. I thought this section was ignored by the compile, but it doesn't seem that way.\nHow about:\nOh, sorry. I didn't even parse that there was a PR referring back to this issue :sweat_smile:\nThat's what the original is, I was very confused by that, and I was trying to update the docs to sufficiently explain the problem with just a short bit of code. The second bit of code was much better at explaining the problem to me, as the question mark implies that the return lifetime is ambiguous.\nIt's also the only place that this notation is used, which makes it confusing.\nSo what should I change it to? suggested\nI think that's fine"}
{"_id":"doc-en-rust-c5f2a754d9cbaec3840bdb2b0cb918bc00e5fadd7efd0de020be6ab7a160fc11","title":"","text":"While working on , I've run into the following ICE. On further consideration, the issue also appears with as long as is non zero sized. This ICE was likely not encountered during testing of because in the case of , is zero sized. In the example below, removing the borrow of will cause the compilation to succeed. could you take a look at this? :) cc you may run into this as well on <!-- Thank you for finding an Internal 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<pFrom playground </p</details\nThis ice is still showing up in . We are using it over in in embedded programming to allocate from heaps located on externally mounted sdram.\nVec is not affected by this, and can even be used to get a Box. This code did not ICE on playground.\nInterestingly, trying to print the Box created in that way gives the same ICE as\nHello, I get this error in two flavor: By ref: Produce the following: Without ref: Cause: Where does implement both and traits.\nI'm hitting this issue too, on code that basically equates to this: Seems like there are plenty of ways to reproduce this in here, but if a minimal test case is needed, I would be happy to try to provide one. I just made a repro, wasn't really that tricky.\nAs far as I understand it, the issue is as follows: std is special cased, it has the attribute This corresponds to , which returns true if the type as been annotated to be a Somewhere, some code which uses makes an assumption that such a box data type only contains one field, the inner pointer itself. This causes the allocator struct field to be removed. This breaks when there is a non ZST allocator field that needs to be accessed in generated code. I'm guessing this might be related to the special deref move semantics for boxes?"}
{"_id":"doc-en-rust-e6bba6f7b972d579d2b8e1f232256163aba5abdf4d072de3787cd60ca44af7e5","title":"","text":"Is the case where the compiler should call for the for the box in the case where a deref move is performed even handled correctly as is today?\nIt seems that is the one that developed the feature, in He had been warned of the incomming issue, , and opt for a \"workaround\", can you give us more information about the problem you , the workaround you choose, any hint for why it isn't working, and maybe give us possible path to explore ?"}
{"_id":"doc-en-rust-6c4d4f3b496f5ae06ffc89ae4053ef8049e709be468f2006bc9bfacc001716c8","title":"","text":"In I noticed this surprising spelling suggestion: To me and don't seem like they would be similar enough to meet the threshold for showing such a suggestion. Can we calibrate this better for short idents? For comparison, even doesn't assume you mean . rustc 1.45.0-nightly ( 2020-05-23) Mentioning who worked on suggestions most recently in .\nI debugged it a bit. is selected as the candidate because the edit distance is just 2 to . The code to fix is likely in or around . I tried some quick tricks but got ICEs and failing tests and gave up. One thing I didn't try that could perhaps work is to consider edit distance between characters of different alphabets/logogram sets as infinite, rather than 1, which is the case right now.\nThank you for investigating! Independent of what we do with different logogram sets (your suggestion sounds plausible), an edit distance of 2 for a string of length 2 should not meet the threshold for showing a suggestion, even within a single logogram set.\nI think edit distance of 1 for a string of length 1 is reasonable (a lot of existing UI tests relies on it), but maybe an edit distance of 2 for a string of length 2 is not reasonable indeed. As you point out, with regular chars, the edit distance is still 2 but is not suggested. So maybe there is a simpler fix to be made for than looking at what alphabets/logogram sets characters belong to."}
{"_id":"doc-en-rust-c790b0598ed9e1e7176eca868d0d82a2e761fe3a9f953b2276ebcabf7316b32b","title":"","text":"It would be nice if the compiler suggested the intended form: as this seems like a reasonable mistake. This is specific to a particular macro, though, so I'm not sure how flexible we can be with diagnostics here.\nOr we could just make the macro accept ..."}
{"_id":"doc-en-rust-d6f19833b4d55a19558c344ec77f996c005c4f43f0f3a11acf2c70ec42b32de6","title":"","text":"This works (but it shouldn't): similar to , cc (tracking issue) label T-lang T-compiler C-bug I-unsound F-targetfeature11\ncc , author of Note that this is about the nostd panic handler, not about the function. This fails as it should: gives\nugh we really need a way to make sure that every single \"this is called by rust\" function gets a check... I assume that these functions can't be unsafe, so I guess those checks are a food way to start looking and make sure to deduplicate the logic there?\nYeah sadly we do need to make sure, not just for the constructs that we have now but also it needs to be kept in mind for the future constructs we add or stabilize. A lot thankfully goes through either the trait system (operators or the GlobalAlloc trait used by ) or function pointers (alloc error hook, std panic hook). Functions that you can make callable solely by setting an attribute, those are rare. The best list of lang items I could find was in the , so that would be a great start for such an exhaustive search. Thankfully most of them are unstable, but still it needs to be addressed for each of them before stabilization (if that is a target).\nWG-prioritization assigning priority (). label -I-prioritize +P-medium\nlabel +requires-nightly\nThere is also another table of lang items in the source code, ."}
{"_id":"doc-en-rust-b7eef13133d1bd518f7438b197bfa559e7a50d7127be663c7758824506ab3e5b","title":"","text":"Tracking issue for (), gated by .\nI don't quite understand fmt internals, but Make fmt::Arguments::asstr() return a 'static str. seems unnecessarily restrictive. And it breaks which depends on hidden apis e.g. Arguments::newv1\ncannot be generated at runtime because it cannot safely be done. So returns makes sense.\nI'd like to be able to use this in the log crate to correctly implement a codegen optimization that doesn't really work otherwise: 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] [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.\nThis SGTM. One question though. Are we sure that the bound will always be correct here?\nis the result from parsing a formatting string at compile time. In the future, this might not always be a literal but might be a too. But a non-static/constant format string will be a very different beast.\nThat's what I figured, but wanted to make sure it was explicitly addressed.\n:bell: This is now entering its final comment period, as per the . :bell:\nDoes this make any guarantees about when is returned? I've been interested in redoing the macro to be much more intelligent (and thus performant), but obviously don't know when it's possible to return something statically knowable.\nCurrently it returns Some for only. But my plan is to extend that also to , , and possibly also things like , etc. See\nYeah, I see that from looking at the source code. I was more inquiring about whether it would be considered breaking to go from returning to returning . I don't suspect anything would be out-of-reach when reimplementing the macro, but you never know.\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-fb9c7186d464c6c0852c78c19c54a7b209964af1b527b13d75d0b30e6d0821e8","title":"","text":"I think you'd generally want to use it as an optimization only, but we can probably guarantee that it will return Some for certain cases in particular (e.g. ).\nThis function seems particularly bad for compressed formatting strings and breaks the otherwise clean abstraction."}
{"_id":"doc-en-rust-4880d19369b37fc6327b2d38c0e4b2ceb8716429da0a8121989862d010b041fc","title":"","text":"(edit: much simpler reproducer at second post) (see edit history for the initial issue text) Potential duplicate of and cc\n(edit: updated to nightly from 2018-08-14, as the error message changed) Another simpler reproducer: Backtrace: The backtrace looks quite different though, so I guess a fix for this one should also be checked to fix the first example.\nLatest nightly appears to have fixed the ICE, however it's still making unbounded recursion :)\nAsync-await traige: Marking as blocking pending investigation to understand what is happening.\nAlright, so here's what I've worked out so far: I was able to reproduce the ICE from the original code snippet using the compiler version and library versions from when the issue was reported ( was the closest version I could find and I had to use patch to make Cargo download versions of libraries that worked). I was then able to confirm that the reproduction supplied in the next comment also triggered the ICE. I was then able to get rid of the external dependencies (mostly by copying in parts of that version of futures) and still get the ICE - . After that, I upgraded to as mentioned in the next comment and confirmed that the ICE had been fixed and the unbounded recursion was happening with that same test case. Then, I took that test case that was confirmed to have the problem and tried to run it on the latest nightly - I had to make some minor adjustments as the pin module had changed since August, but I couldn't get the recursion error to happen. I'm inclined to say that this has been fixed at some point - .\nI've submitted with a regression test for this issue. if you are able to reproduce this failure on a more recent nightly then feel free to re-open or file a new issue.\nSounds good to me, thanks!"}
{"_id":"doc-en-rust-6213aff65410e6fdf6e19c61fb23bd35f7d71bcf17e487ec3b94278260f364d4","title":"","text":"When visiting a page such as or the link src (for the source code) no longer works. Instead a 404 is returned. This seems to have been broken for several days now.\neven before this, many but not all were broken. there may be multiple issues with this symptom.\nThe links link in the form but it seems like the actual source is being placed in a location in the form For example here's a link from the current docs which will 404: But the following will resolve:\nReally annoyed by this. :<"}
{"_id":"doc-en-rust-f0024f2b08d57c7301c2b47611b49433504859a3e9b8193d51ac55f460362022","title":"","text":"Today, nightly crashed on me when compiling my code: https://travis- I don't know what part of the code () is causing this and I don't know how to search for it. Compilation locally works correctly, with yesterday's or today's nightly. I'm trying that new feature. I managed to get this version info from travis in another job: I guess that travis log contains all the relevant information, but if not, please tell me what you need to know.\nmost likely the cause is . Can you remove the target directory and rebuild without it?\nThat seems to have helped… I to the job specification and now it passes. I didn't know travis keeps the directories intact between builds. The new log is https://travis- But I guess that makes it even harder to find out what is wrong.\nThanks for the bug report. This seems to be a problem with our new dependency graph reduction algorithm introduced in\nI believe this was fixed -- can you verify?\nI couldn't reproduce it reliably, it only crashed from time to time, so I have no way to explicitly verify it's fixed. But I haven't seen it crash for quite some time now, so I'd say it's probably solved.\nOK, thanks! :)"}
{"_id":"doc-en-rust-a52e42f77dd548abaa274eb2c4c6b5aa97809ad865c4acc7f4cf65033ef43e12","title":"","text":"I would expect the following command to run the libcore doc tests: This used to work, but now all it does it build libcore and its test binaries. No tests are actually being run (which I verified by breaking one of them deliberately). any idea what is happening?\nI can confirm, doctests are not being run for std. I think a bigger question is, have they ever worked? Cargo will skip doctests whenever is used, which AFAIK is how std is always built/tested.\nI am pretty sure that have used this command before and got test failures when I had screwed up. If you want, I can go back to older versions and verify.\nI'll try to figure out what's going on. I tried running with and fortunately nothing looks broken. It's also very possible I am missing something, but I edited some doctests with errors, and a bare doesn't fail.\nThis was wrong, see below. I'll try to put together a fix.\nOuch. Is there a way we can ensure this does not happen again in the future? Looks like our test suite needs a test suite...\nIt's pretty hard :/ I guess we can add a dummy doc test that writes some \"well known\" file and we can assert that the file is present -- perhaps do this per-crate.\nOK, it wasn't as bad as I originally reported. This regressed via which is only in 1.45 (beta). I have a fix started at This will require various steps: cargo. to beta. cargo on beta. for new beta release. bootstrap on nightly.\nWell, but it does mean that currently on CI we do not run doctests, right? does not change this.\nRight, I just mean it hasn't been that long (only about a week)."}
{"_id":"doc-en-rust-34f5fb938e9d88a3aeb61d1d37a61b5a4e328c732c81db1c30fae7d849556c86","title":"","text":"As I in the i.r-l.o prerelease thread, the documentation of the new(ly stabilized) and method could really use some elaboration before the 1.60 release. I'm quite familiar with refcounting, strong/weak refs, etc. but just from the doc, I have no idea what problem the new method solves exactly, when I should use it, why the closure is needed, how the closure argument seems to come from \"thin air\", and what the closure should return.\nArgh, thanks. Could've sworn I specifically double-checked that I wrote \"cyclic\"…\nProblem the method solves: constructing a which holds a pointer to itself. When you should use it: when you need to do the above. Previously you'd construct with e.g. and then mutate the value (via e.g. ) to fix up the self references. Where the closure argument comes from: essentially, the point of is that the place is allocated first, with strong=0, weak=1. The place has no data yet (you're constructing the value to place there), but is in the \"zombie\" state where it has weak references but no data. Why the closure is needed: the place needs to be \"finished\" once the value is created. In theory, you could \"recover\" any zombie weak, but for the most case, Rust wants to pretend that a \"zombie\" and a dangling are equivalent. What the closure should return: the closure returns the object to place in the reference counted place. After you've constructed the object, the reference count is \"activated\" and the object is accessable by (clones of) the weak pointer given to the constructor closure. For the most part, exists to construct style objects more easily, which is what the example demonstrates. It can be used for other use cases, but this is the primary motivating example. I'm biased because I know what is used for, so the existing documentation is enough. The docs aren't going to be changed for 1.60, but if you (or anyone) can improve the docs (with the above information or otherwise), PRs to do so are welcome!\nI agree I had to read the documentation a few times to understand what this does.\nHi!"}
{"_id":"doc-en-rust-2ba1d12c04163d8be4307341016f856d00395214ee60d6f3fcd4c5bd47922d58","title":"","text":"Just a quick note that changing the documentation for the Rust 1.60.0 release itself will likely not be possible, that'd require a full release rebuild.\nI'm sending a PR with explanations provided by so that it'll at least be in the next release. Why do you need a full release rebuild btw? Isn't it possible to regen the docs without rebuilding everything like the option on rustc?\nI opened Feedback is very welcome. :)\nOur release tooling only supports building everything at the same time.\nWell, at least it'll be present in the next release with a beta backport."}
{"_id":"doc-en-rust-7bc67a81a5a064501183635d7ed8a365f4d521c36f0f8a600ea594dc8f4ad271","title":"","text":"This is the code you are supposed to use according to the lint. It fails to compile, with It compiles fine if you use just one of the two attributes. Swapping attribute order makes it complain about the last non-derive attribute. This seems broken? cc\nConfirmed, this behavior is broken. Possibly related to .\nAs a workaround specific to serde_derive, we allow multiple elements within one attribute.\nyeah, that's what I ended up doing\nThis should be fixed in"}
{"_id":"doc-en-rust-4baf0e8d5127fe6f958b823add21bed6dcb30db386b7af7c0c25faafe018ab65","title":"","text":"File: /tmp/icemaker/issue--2.rs auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details\ncc"}
{"_id":"doc-en-rust-b30bd878d9ffa55a445e79f91b8d3a139d73f3a6a859bd030f675cc33af92f05","title":"","text":"So I had a trait system in my (nightly) code for a while now that utilized specialization, but it no longer seems to be working after a recent update: Now, I haven't been following the development of the specialization feature too closely, so it is possible that this is somehow actually intended and I am missing something. However, given that this previously compiled and ran just fine a couple weeks ago and given that the specialization incomplete warning was only recently, I am inclined to think that it is probably a regression of some sort. compiler version:\nAnother MVCE (): Regressed in , looks like\ncc as far as I can tell this wasn't an intended outcome of the change?\nIt wasn't really, it was just slightly more complex to have this still work after that PR.\nWould you mind describing at a high level what needs to be done?\nIt looks like the problem stems from the bound predicate not being fully normalized when checking the defaulted associated type. From my reproducer above: which should instead be . I'm not certain yet how this ought to be implemented. Perhaps a pass after normalization that looks for occurrences of the defaulted type ( in this case) and replaces it with the defaulted type. Seems simple enough, in theory :) But maybe there are cases I'm not thinking of."}
{"_id":"doc-en-rust-832cebdef14fd0d17c4ca66e6ab34011d84a8be2ca50e6c9567cd93bbb2dca27","title":"","text":"I am new to the Rust ecosystem, but as part of my own learning curve, I wanted to create a small personal project which includes test coverage executed on my raspberry pi server. My setup contains a self-hosted Gitlab-instance (which runs inside docker) running on a 32-bit based Raspbian on my Raspberry Pi 4 (with 8gb RAM). After some hours of trying to get working I tried to reproduce my problems, and found out, that are missing for armv7-unknown-linux-gnueabihf. I opened up an issue on the GRCOV-project (), because I first thought I was missing some important instruction to set up my system. It now seems to me that the package provided via does not include the required crates/libs to make it work to have code coverage being analysed. install the docker engine + docker cli (locally on intel/amd-based system; and on a raspberry pi with 32bit operating system) create a new project in a new folder containing a normal project (inited via ) Content of : create a aside of that folder: create that container: run container: execute the following inside the container:\nMy guess is the version of you are compiling with was built without set in its build configuration (e.g., ).\nThis may be related to\nHm, is related to musl, you sure it is related? As I am using official -image, where can I check/see, if it was built with ? The defaults seem to have no profiler to get built into\nRelated in the sense that both issues report that the build of the compiler for their target platforms does not set \"profiler = true\". Yes, the default is \"profiler = false\", but various pre-built distros enable \"profiler = true\". Some don't. I don't know who makes those decisions, whether we should change this to enable \"profiler = true\" by default in the future, and/or whether the profiler_builtins library works or not for some platforms.\nIs there any update on this? Is this simply a matter of adding to the Dockerfile, or are there other pieces missing too?\nI think this is something pretty low-level to be enabled first inside the compiled rust docker image, nothing that can just be activated via that parameter. I will try to re-check on the upcoming weekend to see if there has something changed silently."}
{"_id":"doc-en-rust-0d0bff20ee419562ade0b0b3ad784288950d2b54e4092b89a069680b0eae8542","title":"","text":"Nope, still the same issue. Retried on a fresh install of the whole system (Bullseye-based raspbianOS ... whatever its called) and got the same output: versions: EDIT: just to point out, the used rust comes from the docker-container, not the hosting OS\nPotential duplicate of ?\nsimilar but no duplicate, because the other issue targets MUSL, this is ARMv7-specific\nRight, but the root cause appears to be an issue with the releases provided for tier 2 targets, which affects both.\nThis already got suggested here: All it comes down to \"profiler_builtins\" not being present. If both issues are having the same root cause, thats okay, but as every target is configured differently (like already mentioned here: ), so I do not see a duplicate here. is specificly targeting MUSL, this is non-MUSL and includes an easy reproducable example.\nIs there a way to activate it when building the compiler manually as a temporary solution?\nTry building with (see PR ). if you get linker errors, try linking with as described in\nI verified that with today's Rust Nightly, code coverage is working. See This target \"just works\"; it doesn't require forcing like powerpc-unknown-linux-gnu."}
{"_id":"doc-en-rust-5e2779214fab88d72f4e5323e0285502eddc8191e8f4de781348aec998d3d8de","title":"","text":"This looks unintentional, and has been broken in all cases, until a few releases ago, AFAICT. Should this be covered by WF rules? cc Unsized constants cause an ICE, in both old trans and MIR trans: Unsized statics appear to work, but only in old trans: I believe this is possible because a constant DST lvalue in old trans is merely the fat pointer. It seems useful to allow an unsized , but IMO it should require a sized RHS instead, i.e.: And, of course, this should all go through the RFC process, to figure out all the finer details.\nShould it be ? I don't think A needs to be an lvalue.\nIt makes more sense for constants, but I gave the example with because that's the only one that works today (although by accident).\nHmm? I mean the static is desugared into a const. works today.\nThe idea being that a static and a const reference both give access to one lvalue.\nNo, has different semantics: it allows an somewhere within and is guaranteed not to be duplicated.\nHmm? Both of these gives me a \"error: cannot borrow a constant which contains interior mutability, create a static instead\". This is what I'd suspect as the lvalue from the promoted has nothing to do with being a or a .\nLet me rewrite my desugaring to account for that, oops.\nOh and my confusion really just stemmed from forgetting about the constants referring to statics rule. [Kind of a funny rule when works, but this is an orthogonal issue.]\nI think in the meantime unsized statics should probably error, perhaps dependent on a crater run, though I doubt there's many people relying on said bug. It's much easier to relax restrictions than tighten them.\nWill prepare a patch to turn this into an error, hopefully nobody has been abusing it."}
{"_id":"doc-en-rust-29afce09f42a612f76d7a6981c4b3b2da2fe69b05479108e0bd4cc862f184ca0","title":"","text":"This is a fuzzed test case, found with and minimized with . I wasn't able to find any similar issues: : <details<summary<strongBacktrace</strong</summary<p</p</details\nThis is related to , do we need to keep this ICE or we cover it at here:\nThe assert was in If you have a reproducer, then it can be to and the assert can be removed.\nlabel +S-bug-has-mcve"}
{"_id":"doc-en-rust-ddd3d00b8a7f65e5e0852598e65996bc0f63d97ff01d7f6798b7ad4f535fc8ec","title":"","text":"suggested this is because when we lower the async function, we add `), whereas it should be parented as something outside of the impl trait context (as that is how such an expression would be parented, if it actually existing in the AST). I have a bit of code where I'd like to use a reference with a lifetime in an \"async\" function, which panics the compiler. I tried this code: I expected to see this happen: My understanding was that async functions are allowed to take references as parameters. helped to debug this a little bit and there is a suspicion that named lifetimes are somehow not properly propagated. I stumbled into this because I wanted to have 2 args with references, but if the lifetimes are elided the compiler asks for them to be . Adding them ICEs the compiler. Instead, this happened: I got a compiler panic. Backtrace:\nsuggested might be related\nIt would appear one can workaround this by using async blocks manually: I still need to test this does what I expect.\nwhy do you need the immediately invoked closure there,\nYeah, just noticed. I think I also had some other issue / ICE, but I don't remember exactly what it was. Gonna have to check it again. Also, I don't think I knew that on blocks was a thing.\nI didn't quite understand why I needed the move. I am trying to fix the original ICE, I think I got some time today tomorrow, hopefully, will make some progress. But compiler newbie, so might not work out.\nYou need to move to avoid the closure borrowing the references locally. It's the same situation as with I just removed all immeditaly invoked functions from eval :wink:\nI am playing around with similar types of borrowing patterns, namely using StreamObj to carry a stream around inside of a struct. I can't seem to use the posted work-arounds: I am taking this working code and I'm refactoring it. Starts as: this works, compiles and runs. Then I try my hand at refactoring to move the stream out of the same scope as the await code pulling out values."}
{"_id":"doc-en-rust-f722c6a44e94a981ee973b3136b65c8363dbc2846ce87bdfb010deac53786c58","title":"","text":"Now I can get the same ICE as this ticket: ICE: full backtrace: Then I try some of your posted workarounds and they don't do the trick, here's my best try: but this fails to compile due to an ownership issue I can't figure out:\nyour final borrow error is because Fahrenheit while your contains a local stack borrow. You could try using  instead of Fahrenheit.\nAlternatively to what suggested, you could move the code in to an async fn:"}
{"_id":"doc-en-rust-f19e8c3b4cc91be92d062a245f376c4f67af088e4fe6f0297917e24bf214b064","title":"","text":"The crater run for merged doctests () detected a large number of regressions due to tests examining the process arguments. (I don't have an exact number, but let's say ~50 projects.) Previously, there were no arguments, but now it gets arguments like which the user's CLI parsing code isn't expecting. For example, using something like  will now fail. It seems to be fairly common to have objects whose default constructor will parse the arguments from the command line. I'm not sure if or how we should resolve that. One idea is to use a different mechanism for passing in the test information (like via an environment variable).\nI vaguely remember that using environment variables was discussed but can't find anything except mentioning it . Maybe it'd be a better approach indeed. Let me send a PR so we can make a crater run on it."}
{"_id":"doc-en-rust-a9511334498e06a54c6bf0f4bd67d9115d74046b72122463958e7ee6eb1751e7","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: param types with same index differ in name'', 'thread 'rustc' panicked at 'assertion failed: param types with same index differ in name'' File: --auto-reduced (treereduce-rust): original: Version information ` Command:\nthanks for the stack trace for this class of ICEs, it's just the right thing that I need. Minimal:"}
{"_id":"doc-en-rust-bcb716d01e0aa92e792c79ce9116a6404c964666a769ff595f0e8e001f55676e","title":"","text":"When using this branch of bitflags: through a patch in a local directory rls crashes with the following errors:\ni had enabled dev overrides for dependencies in using: removing that out the output from rls is now the normal debug flags but still the same errors:\nThis is now causing widespread ICEs in the RLS. Nominating to get this fixed (maybe has an idea?). See for a simpler reproducer.\nI encountered this issue trying out which causes rustc to crash on when invoked by RLS. I can confirm it's the exact same backtrace as\nI ran into this trying out on Windows 10. RLS inside vscode ends up panicking with this backtrace: (note for repro: I had changed the default feature in tui-rs to be \"crossterm\" because the default feature \"termion\" doesn't compile on windows - but after the termion compile errors, rustc was giving me a similar panic anyway)\nJFYI I could work around this problem by adding to my\nI tried that with the tui-rs (it had ) but same panic. [Edit] you're right, I had missed the inside the version.\nThanks !\nRunning into the same issue when trying to build Clap\nSame issue in vscode on linuxmint and rust 1.34.1 when trying to build glib (dependency of gtk).\nThere is no need to list every crate which depends on , it only clutters the thread and makes less visible.\nHere's a small repro, extracted from what is doing: I'm struggling to get a repro without the compile error, though.\nThank you for such a small repro! I’ll take a closer look tomorrow and see what may be causing that. On Tue, 7 May 2019 at 22:32, Sean Gillespie <:\nLooks like isn't written back for a resolution error? That still repros without , right?\nCorrect, it does. Further minimized repro:\nInteresting. I managed to reduce it to: with: Any other combination is okay, it has to be under under and it has to be combined with a field access (bare unknown identifier doesn't ICE). I'm only guessing but it seems that it tries to emplace def 'path' under a which seems to skip a def path segment?"}
{"_id":"doc-en-rust-1560eee77cf6c7650928cb9ddd0f8e103b6279cb08a15618e7077839aa0fe6b3","title":"","text":"I think this is confirmed by A, what I believe is, more accurate guess is that we somehow don't correctly nest appropriate typeck tables when visiting .\nOh, you need to have one table per body: look in HIR for fields and map all of those cases back to the AST. This makes a lot more sense now: so is not wrong, but is looking in the wrong place.\nWhat about this: Seems like we need to before walking the expression of the associated const?\nHm, probably! I imagined the problem is we don't nest it before visiting trait items (hence missing segment) but you may be right! Let's see :sweat_smile:\nWith the fix applied this still ICEs on (this time for type) which means we should nest tables for as well"}
{"_id":"doc-en-rust-6f3d13ef7a299109ffc74393002969f041142ab9e02e44e0b0a7eb37a92184ce","title":"","text":"I know that having huge literal in source is a bad idea, but it should not cause ICE :( It looks like something overflowed. Version: Command, output and backtrace: Here is the generator of the source:\ncc\nTook a quick look. We certainly have a restriction that any file can't be that large, because we use u32 for indexing. And looks like we never try to enforce it anywhere. I think the place to do that would be . Do we have any way to panic without this being marked as ICE? I don't want to thread to each , and this seems like a marginal error where it's totally OK to panic. This is even OK in the IDE context I think: IDE should enforce reasonable max size of the file (something like 10mb, not 4gb) at the virtual file system layer. The \"just panic\" fix is here:\nDo we have any way to panic without this being marked as ICE? or if the context is available.\nI tried to compile the same thing in gcc and clang: With gcc: With clang: EDIT: Opened"}
{"_id":"doc-en-rust-c2194f6c53e42c1510fc29d4bc4b7d8eb6e365d99d9c427c904b1c52b6894602","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 the convenience method . [x] Implementation: [x] Final commenting period (FCP) [x] 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.\nmerge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [x] [x] [x] [ ] [x] [ ] [x] No concerns currently listed. Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\n:bell: This is now entering its final comment period, as per the ."}
{"_id":"doc-en-rust-d3429048aac9abfef320575b4bcc932c8a9999131b120751e6d40ef7279408e0","title":"","text":":bell:\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. The RFC will be merged soon.\nI missed it completely in nigthlies sadly, else I would have proposed it returns the of the old offset, because currently it cannot replace , only the form without assignement."}
{"_id":"doc-en-rust-98451a679af87f0f4a8e5868580b50f7085f668ea298090e21233a6f70f59ba8","title":"","text":"I run cp ans then build && install and I get: $ build && install downloading extracting G:rust-1.59.0rust-1.59.0buildcache2022-01-13rust-std-1.58.0-x8664-pc-windows- downloading extracting G:rust-1.59.0rust-1.59.0buildcache2022-01-13rustc-1.58.0-x8664-pc-windows- downloading extracting G:rust-1.59.0rust-1.59.0buildcache2022-01-13cargo-1.58.0-x8664-pc-windows- Building rustbuild error: failed to load manifest for workspace member Caused by: failed to read Caused by: The system cannot find the file specified. (os error 2) failed to run: G:rust-1.59.0rust-1.59.0buildx86_64-pc-windows-gnustage0bin build --manifest-path G:rust-1.59.0rust-1.59.0 Build completed unsuccessfully in 0:08:36\nCan you say more about how you obtained and extracted the rust source? If you downloaded and extracted from , the directory should be there.\nI downloaded the source from here: and the src/tools/rust-installer is there and is empty.\nAh, the tagged GitHub releases shouldn't be used. They do not include the git submodules. The link above is the one that should be used. Unfortunately we don't have the ability to disable GitHub releases, but we can probably add an error message to x.py if it can detect this scenario.\nI did build && install and got $ build && install Building rustbuild Finished dev [unoptimized] target(s) in 1m 06s warning: creating symbolic link to failed with Incorrect function. (os error 1) Building stage0 std artifacts (x8664-pc-windows-gnu -x8664-pc-windows-gnu) Finished release [optimized] target(s) in 39."}
{"_id":"doc-en-rust-56d1d3dc002ad537264017c219af89a0e831e669310adc3c582317b60024da2c","title":"","text":"65s Copying stage0 std from stage0 (x8664-pc-windows-gnu -x8664-pc-windows-gnu / x8664-pc-windows-gnu) Building LLVM for x8664-pc-windows-gnu running: \"cmake\" \"G:rustc-1.59.0-srcrustc-1.59.0-srcsrc/llvm-project/llvm\" \"-G\" \"Ninja\" \"-DLLVMENABLEASSERTIONS=OFF\" \"-DLLVMENABLEPLUGINS=OFF\" \"-DLLVMTARGETSTOBUILD=AArch64;ARM;BPF;Hexagon;MSP430;Mips;NVPTX;PowerPC;RISCV;Sparc;SystemZ;WebAssembly;X86\" \"-DLLVMEXPERIMENTALTARGETSTOBUILD=AVR;M68k\" \"-DLLVMINCLUDEEXAMPLES=OFF\" \"-DLLVMINCLUDEDOCS=OFF\" \"-DLLVMINCLUDEBENCHMARKS=OFF\" \"-DLLVMINCLUDETESTS=OFF\" \"-DLLVMENABLETERMINFO=OFF\" \"-DLLVMENABLELIBEDIT=OFF\" \"-DLLVMENABLEBINDINGS=OFF\" \"-DLLVMENABLEZ3SOLVER=OFF\" \"-DLLVMPARALLELCOMPILEJOBS=4\" \"-DLLVMTARGETARCH=x8664\" \"-DLLVMDEFAULTTARGETTRIPLE=x8664-pc-windows-gnu\" \"-DLLVMINSTALLUTILS=ON\" \"-DLLVMENABLEZLIB=OFF\" \"-DLLVMENABLELIBXML2=OFF\" \"-DLLVMVERSIONSUFFIX=-rust-dev\" \"-DCMAKEINSTALLMESSAGE=LAZY\" \"-\" \"-\" \"-\" \"-DCMAKECFLAGS=-ffunction-sections -fdata-sections -m64\" \"-DCMAKECXXFLAGS=-ffunction-sections -fdata-sections -m64\" \"-DCMAKEINSTALLPREFIX=G:rustc-1.59.0-srcrustc-1.59.0-srcbuildx8664-pc-windows-gnullvm\" \"-DCMAKEASMFLAGS= -ffunction-sections -fdata-sections -m64\" \"-DCMAKEBUILDTYPE=Release\" -- Could NOT find Backtrace (missing: BacktraceLIBRARY BacktraceINCLUDEDIR) -- Native target architecture is X86 -- Threads enabled. -- Doxygen disabled. -- Go bindings disabled."}
{"_id":"doc-en-rust-3715a07dbb1cab74d6d10d7b8bf79a0db91c5bad25e7513f7fb811c36f73bd42","title":"","text":"-- Ninja version: 1.10.2 -- Could NOT find OCaml (missing: OCAMLFIND OCAMLVERSION OCAMLSTDLIBPATH) -- OCaml bindings disabled. -- LLVM host triple: x8664-w64-windows-gnu -- LLVM default target triple: x8664-pc-windows-gnu -- LLVMHello ignored -- Loadable modules not supported on this platform. -- Targeting AArch64 -- Targeting ARM -- Targeting BPF -- Targeting Hexagon -- Targeting MSP430 -- Targeting Mips -- Targeting NVPTX -- Targeting PowerPC -- Targeting RISCV -- Targeting Sparc -- Targeting SystemZ -- Targeting WebAssembly -- Targeting X86 -- Targeting AVR -- Targeting M68k -- BugpointPasses ignored -- Loadable modules not supported on this platform. -- Configuring done -- Generating done -- Build files have been written to: G:/rustc-1.59.0-src/rustc-1.59.0-src/build/x8664-pc-windows-gnu/llvm/build running: \"cmake\" \"--build\" \".\" \"--target\" \"install\" \"--config\" \"Release\" \"--\" \"-j\" \"4\" [1/2594] Building FAILED: G:/rustc-1.59.0-src/rustc-1.59.0-src/build/x8664-pc-windows- /C \"cd /D G:rustc-1.59.0-srcrustc-1.59.0-srcbuildx8664-pc-windows-gnullvmbuild && G:rustc-1.59.0-srcrustc-1.59.0-srcbuildx8664-pc-windows-gnullvmbuildbinllvm- -gen-attrs -I G:/rustc-1.59.0-src/rustc-1.59.0-src/src/llvm-project/llvm/include/llvm/IR -IG:/rustc-1.59.0-src/rustc-1.59.0-src/build/x8664-pc-windows-gnu/llvm/build/include -IG:/rustc-1.59.0-src/rustc-1.59.0-src/src/llvm-project/llvm/include G:/rustc-1.59.0-src/rustc-1.59."}
{"_id":"doc-en-rust-03b2349abe640ce2ca4f0379f3e6fe72fb4450bbae0044e1d2e0f2e9fb3c412f","title":"","text":"0-src/src/llvm- --write-if-changed -o -d \" [2/2594] Building FAILED: G:/rustc-1.59.0-src/rustc-1.59.0-src/build/x8664-pc-windows- /C \"cd /D G:rustc-1.59.0-srcrustc-1.59.0-srcbuildx8664-pc-windows-gnullvmbuild && G:rustc-1.59.0-srcrustc-1.59.0-srcbuildx8664-pc-windows-gnullvmbuildbinllvm- -gen-intrinsic-impl -I G:/rustc-1.59.0-src/rustc-1.59.0-src/src/llvm-project/llvm/include/llvm/IR -IG:/rustc-1.59.0-src/rustc-1.59.0-src/build/x8664-pc-windows-gnu/llvm/build/include -IG:/rustc-1.59.0-src/rustc-1.59.0-src/src/llvm-project/llvm/include G:/rustc-1.59.0-src/rustc-1.59.0-src/src/llvm- --write-if-changed -o -d \" [3/2594] Building IntrinsicsARM.h. FAILED: include/llvm/IR/IntrinsicsARM.h G:/rustc-1.59.0-src/rustc-1.59.0-src/build/x8664-pc-windows-gnu/llvm/build/include/llvm/IR/IntrinsicsARM.h /C \"cd /D G:rustc-1.59.0-srcrustc-1.59.0-srcbuildx8664-pc-windows-gnullvmbuild && G:rustc-1.59.0-srcrustc-1.59.0-srcbuildx8664-pc-windows-gnullvmbuildbinllvm- -gen-intrinsic-enums -intrinsic-prefix=arm -I G:/rustc-1.59.0-src/rustc-1.59.0-src/src/llvm-project/llvm/include/llvm/IR -IG:/rustc-1.59.0-src/rustc-1.59."}
{"_id":"doc-en-rust-473451c9e84e7a781c3b1df4136171869c06c583bbf855ae3680e1fcfe1bcd19","title":"","text":"0-src/build/x8664-pc-windows-gnu/llvm/build/include -IG:/rustc-1.59.0-src/rustc-1.59.0-src/src/llvm-project/llvm/include G:/rustc-1.59.0-src/rustc-1.59.0-src/src/llvm- --write-if-changed -o include/llvm/IR/IntrinsicsARM.h -d include/llvm/IR/IntrinsicsARM.h.d\" [4/2594] Building IntrinsicsHexagon.h. FAILED: include/llvm/IR/IntrinsicsHexagon.h G:/rustc-1.59.0-src/rustc-1.59.0-src/build/x8664-pc-windows-gnu/llvm/build/include/llvm/IR/IntrinsicsHexagon.h /C \"cd /D G:rustc-1.59.0-srcrustc-1.59.0-srcbuildx8664-pc-windows-gnullvmbuild && G:rustc-1.59.0-srcrustc-1.59.0-srcbuildx8664-pc-windows-gnullvmbuildbinllvm- -gen-intrinsic-enums -intrinsic-prefix=hexagon -I G:/rustc-1.59.0-src/rustc-1.59.0-src/src/llvm-project/llvm/include/llvm/IR -IG:/rustc-1.59.0-src/rustc-1.59.0-src/build/x8664-pc-windows-gnu/llvm/build/include -IG:/rustc-1.59.0-src/rustc-1.59.0-src/src/llvm-project/llvm/include G:/rustc-1.59.0-src/rustc-1.59.0-src/src/llvm- --write-if-changed -o include/llvm/IR/IntrinsicsHexagon.h -d include/llvm/IR/IntrinsicsHexagon.h.d\" ninja: build stopped: subcommand failed."}
{"_id":"doc-en-rust-0aec9eaafb3d77a4bedec18e2a17140b812154abf0540c8b3acc17cff6b42ec2","title":"","text":"thread 'main' panicked at ' command did not execute successfully, got: exit code: 1 build script failed, must exit now', C:UsersDragon boy.cargoregistrysrccmake-0.1.44src note: run with environment variable to display a backtrace finished in 70.343 seconds Build completed unsuccessfully in 0:04:02"}
{"_id":"doc-en-rust-bf9aa06787b60c8699d49c16614a2956727a3497af7c6edbb25f28f3e8d09eba","title":"","text":"From: src/test/compile- Error E0061 needs a span_label, updating it from: To: Bonus: the types could be incorporated into the label rather than a note (though we may want to avoid types with long names in the label)\nPlanning on tackling the bonus here. Is there a prefered max length for output on the console. In the case it would exceed this should i truncate the typename or just not include?\n- great point. If you want to work on truncation, feel free to add it, too. I'm not sure if the term crate will tell you the current terminal size, but it may.\nI'm fixing and I noticed that it and this issue currently share the same code for generating this error, and adding code to add a to the message in would fix both.\nDid you do the bonus as well? I can tackle that if you haven't.\nI haven't yet - I can fix the issue (currently testing/fixing unit tests) and you can take on the bonus part of the issue.\nSounds great to me! Thanks.\n- I opened up issue to track the bonus portion of the work for you."}
{"_id":"doc-en-rust-3361a3a7294dae817db30917d4ab6b69dff616118500b44d6f8b1f69eb3f2804","title":"","text":"Error code: Metadata:\nWhat is the issue you are reporting here ?\nWell, I thought that compiler can understand that is related to the block of code, but it fails.\nCan you post a minimal reproducible example that demonstrates your issue? Or at least mention exactly what you'd expect to happen and why. Even code that is cfged out is still required to parse successfully.\nLet's show you what exactly problem I have. Full code: And I get this error:\nYou seem to already have posted this a month ago. What you're asking seems a rather big change to me, I'm not that familiar with how the compiler parser works but I believe it currently requires your program syntax to be correct before macros are expanded, which is not true for your example, so some fundamental changes would be needed.\nOh, damn, sorry. I totally forgot that I made a post. Well, if it's not a bug and parser works like this it is bad, anyway, exists alternative way to write like this. But for me my issue is a candidate to feature request or a bug. Anyway, I'm not a lang dev, so I don't know what scales of this defect (?).\nThe workaround for this is to wrap the expressions in a block:\nI solved this issue exactly as you did.\nAnother way to do this is using the macro and . I personally thinks it is more clear, and should optimize the same.\nWork is not the same, due to compile-time evaluating an expression that we pass in it and evaluates only it, but at the same time everything compiles what is inside of ."}
{"_id":"doc-en-rust-7a7ae495ffc87e24f18ee8967dbb91001d0a4b48fba5126b914fe62fb1c9ab2a","title":"","text":"compiles without a peep, even though and are unused. Commenting out the gives the expected output:\nI think this an be closed\nThanks (fixed in )"}
{"_id":"doc-en-rust-6282b24f5cf3463648b8a20bf5a3e7d492816f7eb5d365e7f79ac74b0b7fbcf8","title":"","text":"In the in the section it is stated that (emphasis mine) But the example shows a type parameter on , which requires parenthesis-enclosed type parameters rather than angle-brackets. mentioned on IRC that this might be some special case to open the possibility to easier change the traits at a later time (if I understood correctly), but I found it confusing to see a specialization using parenthesis without ever having heard they existed.\nIsn't the text referring to Those angle brackets? \"following the function name\"\nYeah, I suspect the real confusion here is that the syntax with parens has not yet been introduced (nor is it explained anywhere, apparently), so it's the wrong example at this point in the document, and it's not clear to a first-time reader what is being referred to. It seems like there should be a sufficient example here that doesn't use closures, maybe one simple one with and , and one using traits over collections or iterators or something, to demonstrate that parameterized types can appear in the bounds, to make it easier to understand. That said, the reference is explicitly not intended to be pedagogical, and implicitly not yet expected to be complete."}
{"_id":"doc-en-rust-70f5e09fa01366a0094a6b336606df5c1ee0b9941b311de5bfc9b865f6ed7b3b","title":"","text":"Want to fix this bug? There are . This github repository does not contain a trademark file, and I am curious if still applies, as it would seem. Debian and some other distributions are applying patches against the Rust language and Cargo package. I assume this qualifies as something which requires explicit approval? If so, removing or restricting packages from Cargo would also be considered a modification. e.g. some distributions may wish to block access to Cargo downloads that are not in compliance with license standards. Just wanted to get some clarification on this as it is not mentioned here in the repo and some folks seems to think that because there is no trademark \"here\" that rust-lang can be distributed with modifications without approval. I believe the only way such modifications would be allowed unrestricted, is if \"rust\" was not used at all in the package and it was clearly defined as a rebranded fork that is not affiliated with the official package - Otherwise the trademark policy is still enforced.\nThis question should be asked at the linked on the Legal page rather than here.\nJust received a response. It seems a may be useful to direct people to the appropriate from github. This issue can be closed once trademark notification is included or mentioned on Thank you.\nI've tagged this issue as and . To close this bug, we should add a new section to that mentions that there are trademarks on the rust name and logo, and link to If you want to fix this bug and need any help, please let me know, and I'm happy to assist!\nHi I'd like to work on this and opened to add a section about trademarks. But I'm not sure whether I made appropriate wording. Could you please help to review? Thanks a lot.\nAny news regarding this ^ Cheers"}
{"_id":"doc-en-rust-bc908abd879863e27c2dd6519f21b5c6536cc22bc545a3f5db57605791d6239b","title":"","text":"I tried this code (using ): I expected to see this happen: The thread should've panicked with 'Index out of bounds: the len is 0 but the index is 0' Instead, this happened: Thread crashes with SIGILL (illegal instruction) This bug works in stable, beta and nightly. It also does the same in . Here is my (I figured that it might be useful given the nature of the bug). The bug doesn't appear if run from main, nor if run directly (without passing from the Display impl). : <details<summaryBacktrace</summary<prunning 1 test thread panicked while processing panic. aborting. error: test failed, to rerun pass '--lib' Caused by: process didn't exit successfully: (signal: 4, SIGILL: illegal instruction) </p</details\nThis seems to be due to the . Using instead works fine.\nI can reproduce. This seems to happen if LOCALSTDERR is initialized (e.g., with setpanic) which leads us to this . Note that the RefCell there is borrowed so that we can write to it, but then when we go to panic we try to temporarily . This borrows the RefCell mutably, again, leading to a panic. Since this happens within an existing panic, we abort the process. Smaller example:"}
{"_id":"doc-en-rust-0b746ef7bb39b87baa1630231d41ddc7a554881a11dad9107726cf941a2c6908","title":"","text":"File: auto-reduced (treereduce-rust): original: Version information ` Command:\n<!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details\nreally need to add auto-bisection to icemaker reports... Regression in nightly-2021-04-26 found 9 bors merge commits in the specified range commit[0] 2021-04-24: Auto merge of - davidhewitt:revert-, r=GuillaumeGomez commit[1] 2021-04-24: Auto merge of - RalfJung:const-fn-feature-flags, r=oli-obk commit[2] 2021-04-25: Auto merge of - jyn514:no-span, r=GuillaumeGomez commit[3] 2021-04-25: Auto merge of - CDirkx:rt, r=m-ou-se commit[4] 2021-04-25: Auto merge of - cuviper:array-method-dispatch, r=nikomatsakis,m-ou-se commit[5] 2021-04-25: Auto merge of - RalfJung:black-box, r=Mark-Simulacrum commit[6] 2021-04-25: Auto merge of - lcnr:const-generics-defaults-name-res, r=varkor commit[7] 2021-04-25: Auto merge of - RalfJung:miri, r=RalfJung commit[8] 2021-04-25: Auto merge of - jsha:ephemeral-collapse, r=GuillaumeGomez maybe ?\nhm, with , this crashes like this:\nHmm, I'm confused by the result of the bisection, I expected it to find a relatively recent commit since the reproducer doesn't ICE on stable (1.73) (while it does ICE on beta and nightly):\nDoesn't ICE if is enabled.\nthis feature fixing an ice instead of causing one, that's a first...\nThis errors cleanly since beta 1.76."}
{"_id":"doc-en-rust-2768418157edf563d5501b1799ac47f472307da0ad598bb842feb3f59e9eb8f2","title":"","text":"Built glfw-rs using rust 0.10-pre. When referencing this crate in another source file and building, I get error: internal compiler error: unexpected failure This message reflects a bug in the Rust compiler. We would appreciate a bug report: note: the compiler hit an unexpected failure path. this is a bug Ok(task 'rustc' failed at 'assertion failed: ()', ) This is on OSX 10.9: rustc 0.10-pre ( 2014-02-18 10:16:48 -0800) host: x8664-apple-darwin\nThis means that you've got two versions of the same lying around, and doesn't like having two versions. This will be fixed by , I just need to land it :(\nI have just build the library for the first time, and I can only find one dylib for it on my system (next to the rlib, but I gues that shouldn't cause any problems). Is there another possibility for this error? Gesendet: Mittwoch, 19. Februar 2014 um 01:09 UhrVon: \"Alex Crichton\" : mozilla/rust hhildebr : Re: [rust] Compiler error when referencing crate \"glfw-rs\" () This means that you've got two versions of the same libglfw- lying around, and rustc doesn't like having two versions. This will be fixed by , I just need to land it :( — Reply to this email directly or view it on GitHub.\nmy reading of is that having a dylib and an rlib simultaneously is a problem.\nHaving a dylib and an rlib simultaneously should not be a problem, it is in fact quite common. Having 2 dylibs and 1 rlib or 2 rlibs and 1 dylib however is a problem.\nsorry, my mistake in parsing the title of .\nYes, indeed, I had several identical dylibs, but it wasn't the glfw-rs.. there were rust libs in /usr/local/lib and /usr/local/lib/rustlib/... Thanks! Gesendet: Mittwoch, 19."}
{"_id":"doc-en-rust-eb189aebd03b6ca0bdf6b8ced56904a7aac687ebe49e624c5f51beae46de063d","title":"","text":"Februar 2014 um 17:15 UhrVon: \"Alex Crichton\" : mozilla/rust hhildebr : Re: [rust] Compiler error when referencing crate \"glfw-rs\" () Having a dylib and an rlib simultaneously should not be a problem, it is in fact quite common. Having 2 dylibs and 1 rlib or 2 rlibs and 1 dylib however is a problem. — Reply to this email directly or view it on GitHub.\nso can we close this ticket now, in that case? Or do you want to wait for alexcrichton's patches to land, and see what things look like for you then?\nNono, the ticket can be closed for now. Thanks for your help! Gesendet: Mittwoch, 19. Februar 2014 um 21:30 UhrVon: \"Felix S Klock II\" : mozilla/rust hhildebr : Re: [rust] Compiler error when referencing crate \"glfw-rs\" () so can we close this ticket now, in that case? Or do you want to wait for alexcrichton's patches to land, and see what things look like for you then? — Reply to this email directly or view it on GitHub."}
{"_id":"doc-en-rust-16acbb4914bb9992ed29a1710c87156554dd8685769f60cdee2f321edfbae7e4","title":"","text":"The idea of changing a field to unit type to preserve field numbering makes sense for fields in the middle of a tuple. However, if the unused field is at the end, or it's the only field, then deleting it won't affect field numbering of any other field. No response No response <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim"}
{"_id":"doc-en-rust-a8750851288f121bc00952c7894af572c994ac145dc2e0ba8f933073bfede0a4","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. --Input to is able to see underlying derive attributes. This is not supposed to happen as per the change in . A to remove this effect. But onwards, underlying attributes are visible again to derive and this is not mentioned in . Example code is available here: In the following code below, generates a function named which prints all derive attributes visible to it. is defined as: Ouputs a blank line: : :\ncc - I believe the new behavior is the one we want, since it makes derived 'just another attribute'. If so, we should document it more clearly in the release notes.\nThis change was made by , but that PR was never tagged with for some reason.\nTriage: dropping and as this isn't an actual regression."}
{"_id":"doc-en-rust-3db888818268f2e058d840ecf54bc68a793ddb678944677856eed5923b06907c","title":"","text":"An ICE is observable with this code: Changing to take a rather than makes the ICE go away.\nInvestigation shows that will trigger the ICE, while will not\nIntroduced in cc We can probably get away with doing an early return if and no other changes."}
{"_id":"doc-en-rust-ed76f830ed5c30a4ee3d1d23b33a7e4db4b559513f348625c76816a5d6cb1855","title":"","text":"In my Fedora installation ended up being a corrupted file. It took me hours to realize, given that the output does not bring any clarity to it. rustc should really have ratelimit detection or something to detect corrupted file instead and inform about this to the user. !\nThis indeed seems quite confusing; and counter-productive to try to show this blob of errors. Would you be able to provide us with a reproducible example of the issue? Or if you still have it the corrupted file. labels +T-compiler +A-diagnostics +D-verbose +D-confusing +S-needs-repro -needs-triage\nSo this a problem because I unfortunately deleted the trashed file before someone told me that I should report this as a bug. I regret that I did not store it :-/ BUT I recalled that it was probably for reason a long string of ANSI escape codes. So I did a test string: This creates somewhat similar output as I got, except probably the string was a bit longer in my case.\nOK doubling that starts to be almost perfect match:\n! ... I'm considering T-shirt design ;-) Made by me and rustc. EDIT: and rendered by excellent terminal emulator foot\nSomehow rustc should be able to detect corrupted file in cargo's source repository (or whatever it is called). It was pretty bizarre sight when I encountered this by accident.\nThanks for the repro. label -S-needs-repro\nYeah I mean it is really a huge corner case but it can happen in the case of data corruption (e.g. power outage in middle of write operation). I'd detect frequency of errors and maybe a threshold parameter when it is interpreted as corruption with a sane default value.\nyeah, I believe this error comes out from the phase of lexing, which rustc are trying to find all the mismatched delimiters, maybe a threshold is ok for resolve it."}
{"_id":"doc-en-rust-b8922cdf069908d0bfc28d18fae6dfea9a43091c5214d7f002fc9f9f66c23275","title":"","text":"I wrote and got this output: The hint in particular was confusing, since it is targeted at developers who created the impl and forgot to provide a argument, rather than consumers of an impl that is specifically designed to be static.\nWe should probably structure this so that both suggestions are shown. Alternatively, suggest changing the method only when the method is defined in the local crate.\nCurrent compiler message is slightly different: The snippet given for the \"candidate \" seems wrong, shouldn't it present the definition of (or, if that is not available since it's from , nothing)?\nFixed by ."}
{"_id":"doc-en-rust-37acd1f3390bb5eae9106ee301264310bf2b12e6de290416e772a1545c55f554","title":"","text":"results in an ICE (): <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim"}
{"_id":"doc-en-rust-5e375da8fcaf7ba0cd4b1e065f612263c0242430333e5941fba5ee5210f0898c","title":"","text":"When trying to (erroneously) access members of a tuple using square brackets, rather than a period, the compiler gives the message \" error: cannot index a value of type .... \". Particularly as a new user, it would be nice if the compiler could suggest something like \"try using the syntax rather than <tuple[idx].\" This isn't by any means a big issue, but it would help eliminate yet another search through the documentation."}
{"_id":"doc-en-rust-ca843159dc6af61f9432fdda611782921d9eb4e3694e5800c5c222d7719f5ab3","title":"","text":"Reviewing PR had some oversight regarding valid utf8 checks. This was graciously brought to our (meaning myself and attention by in . Fix should really just be changing to setting to , unless we decide there may be some merit to iterating again through the buffer.\nlabel T-libs C-cleanup O-windows\nlabel -needs-triage"}
{"_id":"doc-en-rust-7c73542d67b097e4fd1fee1922c673ac020986f94704300c10704cf32974803c","title":"","text":"The panic payload of the macro (as passed on to ) is generic, but the CTFE panic support assumes it will always be an . This leads to ICEs: Cc\nI guess we could support this, but we'd have to find some way to render the errors. Maybe we need to wait for const traits so we can require const Debug?\nAlternatively constck could require the argument to have type .\nalso requires a\nYeah, the libcore panic machinery does not support non-format-string panics.\nAye, left out the latter of my message. is likely the most common argument to , and it's not unusual with e.g. ; so I agree that waiting for const traits before supporting any other arguments is reasonable.\nIm hitting this ICE on stable without feature flag:\nHm indeed, that is interesting: any idea why we go on here after seeing an error? Does this kind of behavior mean any part of CTFE is reachable on stable somehow?\nyes. We're not gating CTFE on whether there were stability (or any other static checks) failing. I've been abusing this since 1.0 to demo things on the stable compiler and never got around to fixing it. I don't even know if we have a tracking issue for it.\n:rofl: So what would be a possible approach here? Replace such consts by early enough that their MIR never actually gets evaluated? We might as well use this issue, IMO...\nThat would require us to mutate all MIR and potentially even HIR. Other possible solutions: poison the mir Body if const checks fail (by adding a field like or by just nuking the body by replacing it with ) and thus make allow const evaluation to check if the mir Body failed the checks and bail out before doing anything make the have an field similar to\nOn second thought, let's leave this issue for the ICE, and make a new one for \"we can trigger nightly-only const code on stable because we don't abort compilation early enough\":\nGiven that this ICE is pre-existing, as shown by , can we un-block ? I'd really like to see const_panic stabilized, and this seems like a minor issue to be blocking on.\nThat comment is an example of accidentally partially exposing an unstable feature on stable -- a separate bug tracked in I don't see how that's an argument for shipping that feature on stable when it is broken."}
{"_id":"doc-en-rust-21ce43edd15410cd7321881478b82e77d0a12e87f14b1a6a8e5e03c80674bc9f","title":"","text":"In particular, applies to all unstable const features. Fixing this bug here is not even that hard I think: somewhere around here there needs to be a check that the argument has type . Re: , AFAIK that one is also blocked on figuring out how the diagnostics should look like, and a further concern (though maybe not blocking) is .\nI guess that might make this a non-issue, where it is proposed also would require as first argument.\nFor reference: , which was recently merged. The plan is to fix the behaviour of in the Rust 2021 edition. Given that this ICE is listed as a blocker for , does this mean that stabilizing that will have to wait for the next edition?\nNo, because breaking changes are allowed to be made to unstable features without moving to a new edition; that's kinda the whole idea. The 2021 edition will effectively just extend the same restriction to all invocations, const context or not.\nI'd like to tackle this but I'm not very experienced with the CTFE code. I get that we need to check from the that we've matched on in this branch and we need to match on the enum, but: For the first question, I see and that we probably want to check that the type of the tuple and that there's variants of that are , but do we stop the iteration when we get one that is a type? Is the projection list always guaranteed to terminate in a variant of that has a ? And once we have an instance of , do we just check that there's any_ projection in the list that has a ?\nyou can use to get the type of the . Then you can test its to be ."}
{"_id":"doc-en-rust-87fdb067d72819e74c98852b7f8328aabdeb7869b05778cdbbb90b13a5f4412a","title":"","text":"All existing standard library documentation implicitly assumes that the APIs are being used between the start of a Rust and end of . For example  does not document any indication that the function would panic. It does not need to document that, because the function cannot panic, as long as the call occurs within the duration of . However it's possible to observe a panic like this: (Related PR and discussion: ) In general using the standard library from an callback, or before through a static constructor, is UB: according to \"we can't really guarantee anything specific happens [...]; at least not in a cross-platform way.\" Is this worth calling out centrally as a caveat to all other documentation of the standard library? At the top level of the whole crate (it would perhaps be more prominent than it deserves), at the module level, or in the Reference? Certainly for , , , the expectation users need to have is that nothing in there will work outside of . Are there APIs it makes sense to carve out as being permissible outside of ? Stuff like , , , , etc. We'd maybe need to do research into how constructors and atexit are being used in the wild. For example the crate relies on , , and to be usable before : It seems obvious that those things should work but there isn't documentation which guarantees it. I assume that makes the crate technically unsound as written.\nIMHO, core types should work in whatever context but libstd is more dicey. It more explicitly has a runtime or three (e.g. Rust's, libc's and the OS's). So at a minimum anything in the modules , , , , , , , etc should be regarded with suspicion unless documented otherwise. In summary, my thoughts are: is fine depends on the allocator used assumes code is running in main (except for the and possibly stuff)\nCore types can still panic and panics do IO.\nHm... how much of an issue is that? Panics don't have to do I/O (e.g. if stderr is closed) so if platforms don't support that before or after main then it can be silently skipped, no?\nBut do we do that properly today? And it's not just IO but also panic hooks which in turn can rely on various other parts of std.\nI think it would be fine to document that e.g."}
{"_id":"doc-en-rust-269dc65c84419fe490875f7cb05dfdc14afe570942f2ab6c33612886355f811c","title":"","text":"after main they may want to set an empty (or aborting) panic hook if panicking is possible. I really don't want to be in a situation where the user is in a worse place than if they'd just used .\nCould we turn panics into immediate aborts after main? That would also avoid the backtrace printing and symbolication.\nI looked through the standard library, and is the only function that has limitation on usage before/after main (in this case, this is only a problem during TLS destruction). This function is also called from , and , which can therefore panic when called during TLS destruction. and might be able to be reworked to avoid this, but this is fundamentally a limitation of since it requires a reference to the current to work. The stack guard used by the stack overflow handler also accesses the same TLS slot as , but since the stack bounds don't have a this could be moved to a separate to properly support stack overflow handling during TLS destruction.\nIf we're going to make a statement at all then imo we should start out with something more cautious than making solid guarantees since this would be a pretty wide-ranging promise. before/after main behavior is not tested. It is best-effort and if someone relies on it they should have their own tests core and alloc are expected to work because they don't touch OS APIs or global state caveat: user code in any hookable API like panic handlers, global allocators, OOM handler or any future hooks. Especially panics affect a lot of code. we might replace hooks after main? most existing parts of std, backtrace and other things interacting with the OS are expected to work but there may be platform-specific edge-cases and the behavior may change in the future due to changing implementation details or new features that depend more runtime state (e.g. a std threadpool or async runtime) then finally a list of known limitations\nProposed documentation based on my previous comment:"}
{"_id":"doc-en-rust-274e00961750a77a989d49939f2217b84fc9c477167ce26bfce8f7d99db482e1","title":"","text":"The man page for says And yet Miri found libstd calling this function with an alignment of 4 on a 64bit-platform. This happens when size=2, align=4. The fact that size<align makes it enter the code path for .\nThe only reason I can imagine for to exist there is a buggy implementation of . This check is only meaningful if a buggy implementation returns not an allocation suitably aligned for any built-in type (on x86_4 – 16-bytes) but rather an allocation aligned for the particular request?\nA lack of comment is disturbing here. If git history does not reveal any such issue, then we should just remove that check entirely.\nThat extra check was introduced by to fix\nI have opened in jemalloc to get clarification from them about their alignment guarantees. It would be nice if someone with more knowledge could chime in, in particular knowledge about where exactly that value of 16 for on x86-64 comes from. Cc\nPossibly from here:\nC has types with an alignment smaller than are supported in all contexts. AFAICT this includes the memory returned by any memory allocation function - not only , but also . The largest scalar type of C implementations needs to be supported in all contexts. On most platforms, this type is often which the requires it to have an alignment of 16, so on these particular platforms, will have an alignment requirement of 16 bytes. On these platforms, all memory allocation functions need to return memory aligned to a 16 byte boundary when called with a to be able to support the largest scalar type provided by the C implementation. Otherwise would return memory not suitable for storing a scalar type. However, if the memory allocation is smaller than the size of the largest scalar type, then it would be illegal to store it there, so the memory returned needs to only be properly aligned to be able to store the largest scalar type that would fit in that particular size. In practice, this means that for sizes up to , the alignment of the returned memory equals the size of the allocation rounded to the previous power of two (e.g. in a 5 byte allocation, you can at most fit a 32-bit scalar, so the allocation only needs 4 byte of alignment). And for sizes larger than , the alignment is at least (this allows storing, e.g., an array of s)."}
{"_id":"doc-en-rust-6a2014bc6c2e91397c8b0bb7757a0776b1ae02cef99d1d8f8794bbe08d857400","title":"","text":"In practice, the fastest thing you can do, is calling malloc if , because if malloc will return an alignment of at least rounded to the previous power of two, which is always satisfied (remember that must be a power of two, so if its smaller than size, it is at least the previous one). will do this without having to branch on any user provided alignment argument. That's precisely what that code is doing. The else branch is calling a \"generic\" which should be able to handle any user-specified alignment. The implementation of based on : appears to have the bug you mention, and should probably call or similar. I suspect that the implementation of provided by jemalloc, which we use here: doesn't have this issue, because it probably just forwards the call to , which supports alignment smaller than .\nSo basically on the C side, one assumes that is not used with types that use the C equivalent of ? With that assumption, I agree it is enough for to guarantee an alignment of rounded down to the next power of two. (I think your post originally said \"up\", but now it says \"down\" so I guess we agree.) That's what I and our implementation indeed handles that case just fine. The bug in the way we call is fixed by Still, it would be nice not to be able to reason about \"in practice\", but get some commitment from jemalloc -- see And finally, this only concerns on Unixes. Does anyone know what the situation looks like with on Windows? libstd currently assumes even small allocations to be aligned there, and agrees with that (Ctrl-F \"on 64-bit platforms\").\nEDIT: C11 to C, but yes, malloc doesn't know anything about the alignment of a type. It still can be used, but the user needs to check whether the allocation is properly aligned. The docs are quite clear IMO: Anything more concrete than that will be target specific, and those details are outside jemalloc's control - if jemalloc wants to replace the system allocator in a target, it needs to comply with the ABI there. If it were to guarantee more, e.g., all allocations are 16byte aligned, it wouldn't work on platforms using the SysV i386 ABI.\nWell, with that statement from the jemalloc docs is wrong, isn't it?"}
{"_id":"doc-en-rust-195a207e9d5423ad73f3b0d3542db762d1d58e3153786ae0f5b30e3db5e02085","title":"","text":"And for users to manually do the alignment, getting something more concrete would be useful. And also for Rust! Currently you are deducing a whole lot of things from a few words in the spec. I have zero confidence that this is the only way to read the spec. So something like: \"for we guarantee an alignment of ; for smaller sizes we guarantee an alignment of the size rounded down to the next power of two.\" would IMO be prudent to ask from the jemalloc devs. Or else we'll find ourselves with more bugs when someone interprets all this slightly differently.\nI don't know how useful would that be: malloc only needs to comply with the C standard. Parts of it are implementation-defined, and what those are defined to is often specified by the system ABI. That's the only thing the global allocator can rely on. On most platforms, the system allocator - which is the default global allocator for Rust programs - is not jemalloc - it is the one from glibc, musl, microsoft, apple, google, mozilla, etc. In some platforms, like FreeBSD, the system allocator is jemalloc, but even there we can't exploit that knowledge because users can just and now the global allocator is a different one. That's an use case we support. So even if jemalloc were to offer extra guarantees here, Rust's system allocator cannot make use of them. The only places were we can can exploit jemalloc's specific guarantees, is when using crates like jemallocator, to explicitly hardcode the allocator to a particular one. As in, if that allocator is not linked, you get a linker error or similar. But even there, it makes sense to stick to what C and the platform ABI guarantees, because jemalloc is free to break anything else in the next version.\nWell it would save us this entire discussion. If that doesn't demonstrate its usefulness I don't know what does.^^ I don't know what the \"system allocator\" is for Linux, but the one in glibc actually guarantees a 16-byte alignment on 64bit systems for all allocations. So by that standard jemalloc would just be incorrect.\nThe platform ABI guarantees that. What the malloc implementations guarantee is irrelevant."}
{"_id":"doc-en-rust-42b2de4c9c2f2f1395d8e2119abdb03e165e405c04ffb252370c22d3d32bbb38","title":"","text":"If glibc were to guarantee that all addresses are 32-byte aligned, there is no way in which we could exploit that information in the implementation of the system allocator, because the platform only requires 16-byte alignment, and it is valid to pick any allocator at run-time that satisfies that.\nSo there a document somewhere saying \"for x86-64 bit, 16-byte alignment is guaranteed\"? But that document contains an exception for small sizes, making s behavior legal?\nYes, there are documents containing the rules of what's legal, at least for Linux x8664. Those document allow an exception for small sizes. One API that uses those is , which requires the alignment to be at least , which is 8 on x86_64, and which allows you to allocate bytes, with a smaller alignment. I still have no idea what jemalloc has to do with any of this - your original question is about , and that has nothing to do with jemalloc. But yes, jemalloc exploits this behavior, to be able to satisfy 1 byte request, and return addresses that are 1 byte aligned. Otherwise each 1 byte request would consume 16 bytes of memory within a memory page.\nA document that could be relevant is the C standard. Unfortunately, as mentioned in the commit message for , it is rather tautological on this topic: The standard does not give any numeric value. Like many other aspects of C, it looks like the actual value of is implementation-defined.\nWhen using jemalloc, becomes jemalloc. That's how happened. Do you have a reference for something that concretely calls out an exception for small types? The C standard only does this very indirectly, as you showed.\nThat was a bug in our implementation of system that applies to pretty much all allocators, not only jemalloc. says (emphasis mine): Since the alignment of an object is a power of two that is always smaller than or equal to the object size, rounding down the alignment of an allocation to the previous power of two always produces an allocation properly aligned for every type that can fit it. That holds for all allocations, so there is no exception for that. That's the rule. Since that would mean that large allocations must be unreasonably aligned, the standard does provide an exception for allocations of size larger than than ."}
{"_id":"doc-en-rust-e05ac4321d48d2f8a21035e164ad9a84191f03cab40ec425dd16d385d3cf402f","title":"","text":"These only need to be aligned at an boundary. If you believe this is incorrect, please show a counter-example for which this doesn't work.\nAFAIK it is a normal way of using to make it override the symbol? Don't we still do that in rustc, or when using \"jemallocator\"? I don't say it is incorrect, I say it is awfully indirect. It's like reading tea leaves. I am looking for a clear definite statement. That doesn't seem to exist though. :( There clearly is some kind of \"non-continuity\" where all allocations are aligned MINALIGN except for small ones. Or vice versa, all allocations are aligned \"size rounded down to power of 2\" except for big ones. You are convincingly deriving that non-continuity from standard wording. I don't say you are wrong, but this feels like interpreting ancient scripture. A clear spec looks different. Also, an object of size 2 with alignment requirement 4 is \"fundamental\" according to your definition, and yet rounding down the size to the next power of 2 does not give the right alignment. So your rule does have exceptions, namely types marked .\nCan you show such an object in C and/or Rust ? It's probably the most common way of switching allocators. What does is it requires to be linked to your binary, allowing (and making use of) jemalloc-specific APIs. If you do this, when using directly (not ), you can obviously rely on assumptions that only hold for . But cannot do that because, then it wouldn't work with other allocators.\nThe goal is not to rely on assumptions that only hold for . The goal is to make sure that we do not make assumptions that don't hold for . Because that's what we used to do, before got fixed. We were assuming something that was true for system but not for : that all allocations, no matter the size, are aligned. To make sure we don't do that again, I want to be sure that all assumptions we are making hold for . That's why I'd like jemalloc to spell out what we can assume.\nAh I forgot about the stride vs. size thing. So such an object does not exist."}
{"_id":"doc-en-rust-a835cfab690241d43fcf339b6b088eec02bd9664d4638636512f590be6c89bb5","title":"","text":"But such a exists, and it is something we want to support in our allocator API (we even have a test for that). And we do have objects with align size, namely all ZST.\nYeah, I agree. The only cases for which the \"round to the previous power of two approach\" doesn't work is for ZSTs, and types (or allocations) with align size. Since those just cannot happen in C, the C standard doesn't mention them as exceptions. That is, we can only call when that holds, and if it that doesn't hold, we need to call a different API that supports the align size case."}
{"_id":"doc-en-rust-82f7e2f4bcd5ad1d9801526438d64ab9e6051cb70d3ce64397f13aaf700a1c74","title":"","text":"I've seen this quite a lot recently Example logs: Example Travis runs: https://travis- https://travis- https://travis- https://travis- I'm opening a tracking issue so we can collect some more logs and hopefully draw conclusions from them at some point. Until then I'm not really sure how we'd deal with this...\nIs there a way to collect the coredump from the segfault so we could attempt to track down the reason behind the segfault? Perhaps we could at least pass to clang so we could try to reproduce locally?\nyour guess is as good as mine!\nIf you set , the core dump will end up in .\nhttps://travis- is the first job where we got a stack trace: I wouldn't necessarily call that... illuminating\nI wonder if there would be a way to print what the files we're linking are? Maybe that would help since maybe the linker segfaults on an improperly formatted file or something like that; knowing what the files are (names and lengths) may help. I think passing to clang would be good enough, at least as a start.\nPRs are always welcome! I don't have any magical tricks up my sleeves to implement tricks like that unfortunately.\nNext successful stack trace: https://travis-\nanother failure of this kind https://travis-\nThese look like assertion failures: Now the question is how we recover the assert message. Any Mac person knows of a way?\ngood thinking, I totally missed that before! Looks to be: (that's a disassembly of the executable on my system, which looks to be the same). I believe and sure enough there's in the source\nWell the pthreads explains why it's nondeterministic at least...\nRandom attempt to help this:\nLooks like did the trick, we haven't seen this in ~2 weeks, so closing."}
{"_id":"doc-en-rust-eea14e77b1002ed77ffdaae22bcc44c632112140cc820f8261acd02eb4c0008d","title":"","text":"The suggestion that rustc gives is incorrect and seems to not take into account what characters are in the format argument. I tried this code: I expected to see this happen: Instead, this happened: Using beta.2/nightly : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nlabel -C-bug +A-diagnostics +T-compiler\nclaim"}
{"_id":"doc-en-rust-53b468da9a6f195e87239ffd5e42111fc27af1e44172af9e2e84695d7d539a57","title":"","text":"Alternate title: \"Rust is literally C++\" As of nightly-2020-10-29, rustc fails to parse the following code. The previous nightly and all past stable releases since 1.0.0 are not affected. The relevant commit range is\nMentioning because \"Tweak invalid  header and body parsing\" sounds extremely relevant.\nAssigning and removing as in the prioritization working group.\nsearched nightlies: from nightly-2020-10-27 to nightly-2020-10-29 regressed nightly: nightly-2020-10-29 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: </detailsYeah, seems likely that is the culprit.\nYep, this was me :-/ I'll have a PR up in the next hour."}
{"_id":"doc-en-rust-a950a660acb91d70b8b4626ffdafe37172eb2873a306de813dafa2ee4d8f9db9","title":"","text":"Currently (something after 0.5) rustc (IIUIC) is using rpaths to point libs and binaries to the appropriate locations. This is problematic when rustc and the other libs/bins are package e.g. for Fedora. The rpath usage should be made optional - can be used instead - and LDLIBRARYPATH.\nWhy is this problematic for packaging? Is it because the rpath values end up with the wrong values? Each crate's rpath has several values, one of which is supposed to be the final installation location (controlled with ). Can we just provide more control over which locations are used during rpathing?\nIn general Fedora recommends to not use rpaths [0], because the paths are hardcoded in the binary. Fedora preferres to point the dynamic linker to the appropriate paths [1]. But yes, we are more flexible about internal libraries - which the case is here. So yes, it would also help us if we could controll the rpath path (which goes a bit into the direction if issue ) [0] [1]\nThe following rpath is used in e.g. the cargo binary: The rpath referres to rpm's buildroot, where the lib won't stay (it will be instaled to ) Maybe the problem could adressed if the rpath would respect - but this could lead to problems at build time. Maybe LDLIBRARYPATH can be used to point to the correct dir's at build time, and the rpath can be used to point to the correct dir's at runtime. Just my 2ct - but you ar ethe expert :)\nThanks for those links. We do generate rpaths with the expectation that some of them will be invalidated by moving the binaries around. It's possible we could consider removing rpath, but it sure is nice to not think about dynamic loading when running binaries out of my build directory. We could easily add a flag to the configure script, to turn off the rpath for all the rust-provided libraries, with the assumption that package managers would modify during install. If we did that I feel like we would still want the installed rustc to generate rpaths with user-built libraries - otherwise the experience would be different depending on the rust installation. We could also just remove rpath completely - it doesn't work on windows anyway."}
{"_id":"doc-en-rust-5151270ffdeea50f64b201e1c8168f621692c15bd4b7ae2d4388d3b0d3a4f6d7","title":"","text":"Another thing to consider is that, if we just used rustpkg for all builds, and let rustpkg install all libraries at a known location, then we might be able to conveniently not use rpath while still doing the right thing at load time. Can user directories like be put into ?\nYes - I can fully understand how easy running rust in the build directory is when using rpaths :) For the build directory use case it should be possible to create wrappers for rustc and friends which use to point to the correct dirs. You mention thet some libs might reside in , could you explain the overall concept you are following with this? In general I'd expect libraries to appear in /lib, /usr/lib some and some private /usr/lib/myapp. There are also some xdg specs that specify and - but let usfirst see what you say about ~/.rustpkg. Oh, I don't think that ~/.rustpkg would be expanded correctly if put into\nJust to summarize my thoughts: If rpath is used, the rpath path beeing used should only use directories below (to point to non-standard dirs containing libs relevant for a rust component). The rpath path should not point to any build-time dir. To include libraries at buildtime or when using the binaries in the build directory I'd suggest using wrappers (isn't autotools doing it like this?) which set appropriately.\nAny follow up thoughts?\nOur package manager will by default not be installing libraries to a system location and will instead put them in the user's directory, . This doesn't seem out of the ordinary to me; consider cabal, etc. The behavior you recommend requires some deep changes to how Rust works, so need to be considered carefully. Does the current behavior prevent packaging in Fedora, and is there a minimal change we can make to unblock packaging? You'll probably be interested in this subject.\nThanks for the rustpkg explanation. Do I understand that rustpkg will create binaries and libs with rpaths pointing to the user's specific rustpkg dir ? My feeling is that this user specific rpaths should be configurable at build time. The use case is obviously when the binary or lib is going to be installed systemwide. The only rpath exception is the rpath pointing to the system wide package specific libdir (e.g. )."}
{"_id":"doc-en-rust-7b543ce276287a523dcf1a37842437cfe9a628174cf6714aeeb2711fab0a1543","title":"","text":"I think that I'll spend a bit more time with looking at and and might get a better feeling for the problem. Btw.: I noted that the libdir isn't configurabel. Fedora for example keeps x86_64 libs in (/usr)?/lib64, and i686 in (/usr)/lib. IIUIC this is currently not possible with rust as the libs will be installed to /usr/lib/arch-specific-path\nThe point about libdir is well taken and I updated . I am not entirely sure how rustpkg does it's build now or how and intend for it to work, but based on the current language design I would expect that, yes, binaries installed to would have rpaths pointing there. Currently there are several rpaths configured for each linked library so that they hopefully fall back to something useful when the libraries are moved around during install or during the bootstrapping process, something like: The relative path to the library The absolute path to where the library was at build time The system installation path Under this scheme I would expect that would, when linking against libraries in , create rpaths to .\nYes, there are several rpaths used (seen in and ) and I'd say - even with looking at rust itself, without the packaging glasses on - that it should be configurable what rpaths are used. Maybe it should be an option of . As said, system wide binaries are the best example for binaries where you don't want to many rpaths - including no rpaths pointing to some user dir.\nPlease don't tag TJC :(\nSorry, TJC! Maybe it's time to give in and start working on Rust :) Seriously though, sorry. I'm sure it's a real PITA.\nmentioned that this is a security issue, which I didn't realize. Debian also says .\nBy the way, it's possible to strip this with but it would be much nicer to not require a third party tool.\nI generally wonder why you don't add a user-specific to to point to the user specific rustpkg dir instead of using rpath. That makes it much easier to cope with - and that would also be in par with (at least) the Fedora guidelines. And I suppose with Debian's too, as it's the common way. (See 3rd party java binaries. They modify the to point to some hidden dir in the userdir.)\nWe used to."}
{"_id":"doc-en-rust-bde3b6ae1e3e98b475a33f9a1a8a3307672213332add48ee4a6c55c0b0f17136","title":"","text":"Users kept forgetting and/or getting annoyed having to adjust it when running from a build dir. Rpaths made it possible to run foo/bar/rustc no matter which rustc you chose.\nright. IIUIC - I always feel like a noob when it comes to autotools - autotools are generating wrappers for binaries which are created during a build process and moves the original binaries to hiddend irectories. The wrappers are then modifying the environment (setting env vars etc) to achieve the same goal (so e.g. that rustc can be run from the dev directory without messing with the env vars yourself). I wonder if this could help.\nOkay, it's actually not autools which creates these wrappers but libtool:\nSorry, I didn't mean to imply a disinterest in fixing this better, just noting how it came to be. Also strongly disinterested in using libtool. Would prefer going back to telling users to set env vars.\nHow about defaulting to static linking (when it works)? Dynamic linking is valuable, but mostly for global installs handled by a package manager. Of course, if we end up with a bunch of tools using that would be wasteful. I think RPATH will just lead to confusion, and it's an easy security hole to leave open.\nI would be very happy to get static linking working well enough to make it a default in many such cases. But we ought to do the right thing when linking dynamically too. Is rpath-using- considered acceptable? I.e. is it just the absolute paths that are problematic?\nThe absolute paths are the ones that can easily be a security issue, so isn't that bad. I would still rather avoid it for a globally installed package but it's easy enough to strip for people who don't need it and won't be an issue if you don't know about it (like the absolute path could be). Using the rpath could be a flag, but the absolute path should never be there.\nNominating for milestone 2: backwards compatible. (The choice of whether one needs to put a setting in or use some configure flag for certain systems, etc, seems like a backwards compatibility issue. Though maybe I misunderstand and these are issues only for people developing itself, not for clients of ?) It also could well be that this is more appropriately assocated with milestone 1: well-defined."}
{"_id":"doc-en-rust-e2ab7893880a27d6b67cf522b730616f8bf2b057dd45e0e57f81fe2174c90e4c","title":"","text":"I suspect and have a more concrete notion about this.\nI don't have anything much to add to this despite it coming up for triage today. I think it has to be fixed still, I'm still happy to do it via whatever combination of static linking by default and use of is sufficient for packagers, and I haven't seen any clear movement on it in the meantime.\naccepted for backwards-compatible milestone\nI'm getting worried that we won't resolve this for 1.0. I agree this is important to fix. Here's my current suggestion: Modify the build system to once again set LDLIBRARYPATH/PATH to find the appropriate dynamic libraries. Add a flag to rustc to disable rpath Add a configure flag to disable rpathing the rust build itself. Packagers can use this to do whatever they want. With this logic the rust package itself could avoid rpath where distros have their own way of dealing with library paths. The rustc installed by these distros would still be rpathing user's crates for the sake of convenience. Is this an acceptable compromise or do distros want us to completely disable rpath? I'm afraid that doing so would provide an inconsistent developer experience depending on how rustc is acquired; if we need to do that then we instead must find a way to completely eliminate rpath.\nIf we start to just statically link everything by default then rpath becomes much less important and we can just say it's up to users to figure it out if they opt into dynamic linking.\nI think we should completely remove absolute rpaths. It's okay to have $ORIGIN-based ones but it may not be a good default. I'm not sure what the answer is to that, but agree that static linking basically resolves this.\nIt doesn't appear that this is fully working. There are still rpaths in the binaries when configured with even though the flag for rustc does work. /usr/bin/rustc: RPATH=$ORIGIN/../lib:/build/rust-git/src/rust/x8664-unknown-linux-gnu/stage1/lib/rustlib/x8664-unknown-linux-gnu/lib:/usr/lib/rustlib/x86_64-unknown-linux-gnu/lib\nWhat steps did you follow to having the rpath show up? I thought I double checked on linux that the configure flag worked, but I may have overlooked something."}
{"_id":"doc-en-rust-205d33f2c4ca407a5eba587eb9d79d5b66428139a1f256eedc1fb0c137300290","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: [typeck] type-checking [analysis] running analysis passes on this crate --\ncc"}
{"_id":"doc-en-rust-e50af215174b6184602adb938425db76e7242910ad97b6f43300eeb640dddd67","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: on stable 1.78.0, this checks in 0.02 seconds. on beta 1.79.0-beta.3, this hangs somewhere in , I killed it after 5 minutes of no progress.\ncc\nSharing the stack would be useful\n:thinking: that doesn't really seem to be it\nYou need to switch to like thread 2 or 3 if you're doing this in gdb\nit's not particularly deep, but it looks downstream of so I guess this must be it\nMinimal:"}
{"_id":"doc-en-rust-94c535fad036b284e575a8eb6646f76a1ca84c78827b75820bbc1300a2d31091","title":"","text":"Same error, with the last github version.\nAlso getting this, I'm running the Yosemite GM 1. Not sure if it's related.\nI also getting this on MacOs\nStill getting this make error, like many others did. Anyone want to fix this?\nI have no idea how to fix this, other than just installing xetex or however it's spelled\nThe configure(or make) did find LuaTeX.\nSadly I don't have time to work on this right now. A simple fix would be to disable pdf generation unless specified in configure, or to require xetex.\nI don't think that LaTeX should be a dependency to build a programming language like Rust.\nit seems reasonable to have the option to not build PDF docs if you don't want to\nI think I'm getting the same error, which is strange because I believe I was able to a couple days ago. In the log, the complaint is that is not found. As suggested above, is included with MacPorts' package and installing that allowed compilation of docs to go through.\nwill build without building the PDF docs"}
{"_id":"doc-en-rust-fbcf93ffe5d79d5436279a56fc0f593fdd4ac3505379f6d91fe56dd005b9bc92","title":"","text":"Error happened while working on updating closure capture analysis in rustc which is part of rustctypeck. The highlighted line is what changed between the build that broke and the build before 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. --Version reported in build log and similarly one or two more Complete build log: Build log with : Build directory: (Heads up, this is 29G tar, 39G extracted)\nWhat was the exact build command that caused the ICE? If this is with , then I also see this issue every now and then. Locally built rustc all have the \"dev\" version string, which means it doesn't have to rebuild everything just because you do , but it also means it cannot detect that the ABI changed, so it might try to load old files with the new rustc and of course that will fail. I am not sure if much can be done about this.\nSome potential duplicates: , , ,\nI do . This happened to me again last night: The assertion is fired in the not the same line but the same file, I haven't gotten around looking at the query code to see what failed. Only thing I worked on since the last x.py clean (maybe 10-15ish builds in, though I could be wrong) was change closure/generator pretty printing (in rustcmiddle/src/ty/print/pretty), haven't rebased since. Though I can see that rustc builds are themselves are more prone incr compile errors, also didn't think had anything to do with the build process, otherthan maybe some version strings.\nCc I mentioned because one way to avoid this problem might be to embed the git commit in the version string used for rebuild detection -- but that would be rather annoying in many cases.\nYou can set ignore-git to false in and that'll embed git commit hashes. But I think that must only patch over bugs - it can't be necessary. I doubt it will fully fix this bug. I suspect the problem is that Cargo doesn't delete incremental state on dependency changes - which means that rustc must be prepared, currently, to see incremental state serialized by a different rustc... ideally, handling that in a way that doesn't just throw everything out, but even just not panicking would probably be enough."}
{"_id":"doc-en-rust-133e1a71440a83cb57fcda12ab1e3b796bc2c3a2ffd79af3a690d9df00779836","title":"","text":"See also\nThe proper way to fix this is to wipe the build cache whenever the stage1 compiler changes. That will make builds a lot slower, but it's better than ICEs and having to wipe the cache anyway. I guess we could add a --keep-stage1-cache flag if you're sure you haven't touched metadata - not sure how useful it would be in practice. said on Zulip:\nWait, I'm confused again. Why does the metadata matter other than the incremental cache? Cargo already invalidates the cache when is modified, which is why libstd gets rebuilt when you modify the compiler. Is there anyone not using that's been hitting this issue?\nI found while working on that this is not true: if you use --keep-stage-std 1, cargo will blithely keep the cache for all crates in build/stage1-rustc, without rebuilding. Copying over my comment from\nAnother possible fix is to make rebuilding after a commit cheap enough that we can include the hash unconditionally. Right now it's used in rustcsession; if we move it to rustcdriver, that would only need to relink the .so and recompile the final rustdoc/clippy/miri crates, not their dependencies. I guess it means we'd have to suggest using keep-stage-std more often :/ but people are doing that pretty frequently already.\nOh, and it has the downside that if you're testing the project on external crates cargo will recompile them after every commit. Maybe that's a good thing?\nThe only time it won't fully fix the issue is when you're modifying rustc_metadata or similar and don't make a commit between builds. I'm ok with not fixing that case, because anyone working on metadata is much more likely to understand what went happened and how to work around it than random contributors stumbling into this for the first time.\nhit this issue this morning with incremental disabled, so it's relevant to all metadata loading, not just incremental.\nThanks for pointing me to the right issue. Following Tried some commits from the past few days Would it be useful to keep going with this approach? Oh, and this is with .\nThat's helpful, thanks! No need to find more commits, having a reproducer at all is already very useful.\nThis fundamental issue doesn't just apply to bootstrap, right?"}
{"_id":"doc-en-rust-0daa1d2dadc9c7ef99410d78555ddfd49a327fdc4837783bcfe6fd4419f9a8ed","title":"","text":"If one uses a locally built toolchain to build some crates, and then updates the toolchain, the same ICEs can arise (because the dependency rlibs will now be in the wrong format). Bootstrap is just where people run into it most often. But a solution inside bootstrap won't fix the fundamental issue. (E.g., it won't fix the Miri version of this problem, which got reported at )\nYes, that's right, any two toolchains that were built from different sources but have the same version string will have this problem (this is why we set a custom description by default in the source tarballs, so they won't reuse metadata from the official toolchain). Removing or defaulting it to would work for miri though, or at least make it so that you have to try a lot harder to run into the bug (e.g. twice with different local changes that haven't been committed).\nA more \"principled\" fix would be to have something like a metadata version number embedded in the files that contributors are responsible for updating when the format changes. But I worry people will forget to update it, the same way people often forget to bump and that causes caching issues:\noh right, and suggested adding incremental to dep-info: but given that this bug is also showing up for metadata, not just incremental, I suspect that's not a complete fix:\nYeah, if we could somehow ensure that such a version number is always correct it would be a proper fix but manual bumping probably won't work. Unless we find a way to at least have CI fail when one forgets to bump...\nreported seeing these crashes for , not just for tools and stage 1 rustc. I think he's running into this line being buggy: that shouldn't filter only to build, nearly all the commands read metadata and need the same treatment. Not making a PR because I don't have a test case yet, but if anyone comes up with an MCVE that makes crash, I'd be interested to see if this diff fixes it: also, I wonder if we could fix the original problem with metadata/incremental in stage 1 by applying clearifdirty to rustc too:\nreproducer unfortunately gives me a different ICE than the one in the linked issue; it's for stage0, not stage1. So I can't use it to test my diff."}
{"_id":"doc-en-rust-8f47ef98bd519f7002a55f257848d6b02c49da07d2006a9d47e5c411ca3eb89e","title":"","text":"a while ago found that reproduced the issue; if someone could run that both with and without my diff applied to see if it makes a difference that would be helpful; I'm out of time for today."}
{"_id":"doc-en-rust-3934a1b92c7e17508c6b88bced70af5d14e1d80fcd45b847830b1281e6361ebc","title":"","text":"It looks like if you go and grab this commit of timely-dataflow from github, you get a nicely reproducible ICE. TravisCI gets it too! In case anything changes in the meantime, the commit you want is Related issues: . The times I've seen this before I haven't be able to reproduce it, but since it seems to happen from a clean pull, I thought I would show you. To repro, just follow the commands here. git clone, cargo build, cargo test. Boom!\nIt seems like I can make the ICE go away by replacing a member variable with one that uses an equivalent trait which doesn't use associated types: Swapping that in removes the ICE, swapping it out brings the ICE back. So, maybe something isn't working great for boxed traits with associated types. The commit that fixes things is\nDoing some testing, and the repro in (not mine) is way simpler. It also explodes on 1.1 stable, with a similar complaint. Just boxing a trait with two associated types.\nI run into this problem, too (with stable )."}
{"_id":"doc-en-rust-59896f2a78933cbb77beb7a499e617bbdcbb69e9c72cd913fbde9be24226cf8c","title":"","text":"Hi, I ran into an interesting ICE while working on a personal project. This seems like it could be related to issues or , but I'm not sure. I set up a . The README includes a description of the bug and the compiler backtrace.\nGetting the same ICE occasionally in (At more specifically, not minimized because I don't think I can produce a smaller example than the package above).\nThis is a somewhat flaky ICE I used to see a bunch back in April, but it seemed like it sorted itself out with the 1.0. I've found it again! It is on stable 1.1, so I thought I would bump this post 1.0 issue rather than my open pre-1.0 issues. I'm really not sure what causes this, but the common features tend to be doing a bunch of builds with light changes to a local crate (path=\"...\") on which the project depends (in this case, local edits to the timely crate). It feels a lot like it is Cargo getting just a bit confused about what has changed and what hasn't, as will sometimes fix the problem. Previously, toggling LTO would tickle/untickle the bug, as would insisting on some inlining. Just now, fixed it up, after would not... Maybe someone should just put a on the bounds list... =/"}
{"_id":"doc-en-rust-a39767ff1fc582a70382e095be04a350d7ea60ab147cde1462399fe395d9bbb8","title":"","text":"Taking a look.\nProbably the best fix for now is to disallow deref of outright. I'll work up a PR that fixes this and a few other ICEs surrounding .\nThis is fixed with a test, closing."}
{"_id":"doc-en-rust-4a7600821179f28fd56e4a7cc14a1030486d51f3aca63e8d8f47943e4bde5b79","title":"","text":"While bootstrapping on Fedora 25 armv7l, I'm hitting a SIGILL when some beta-compiled programs are actually executed. This is with a purely default , no external LLVM or anything. On beta (exactly ), I get a little ways into stage1, and then build scripts SIGILL, apparently from double-panics. I reckon that the stable stage0 builds a stage1 compiler that's fine, then that stage1 starts building things that don't even need to execute until we get to a build script. Then: So I also tried the master branch (exactly ), and that fails as soon as it executes at the start of stage1. Here it seems that the downloaded beta stage0 compiler builds all of its stuff fine, which presumably includes executing some builds scripts like above. But the stage1 it creates seems to be bad: I traced through with gdb, and it's not actually crashing, rather the that it execs into. Here's the backtrace: That looks like a triple panic! The actual SIGILL is delivered for a instruction:\n(side note: on the beta branch I have also applied , or else you have to configure with an explicit to get armv7.)\nI tried to build a debug nightly, but it can't link to in stage0's librustcconstmath:\nLooking at , it seems SIGILL is expected because of the . The questions are then, why did it panic in the first place and why did the default hook panic?\nis where the default hook is panicking.\nYes, I agree the SIGILL is just a symptom of the nested panics, not something to fix in itself. While I couldn't get a debug build, I got a release build with debuginfo. Here's a better backtrace from running : So the first panic comes from the failed at frame called from . The line right before got a shared -- maybe something isn't marking this released properly? Then the nested panics come from trying to read this same broken , with frames and also trying to .\nLooks like you are using an LLVM without the fix in . That will blatantly miscompile rustc and lead to severe problems.\nWhile it does sound the same, unfortunately no, this is with the rust-bundled LLVM, including your fix."}
{"_id":"doc-en-rust-fc8d2a7551b91b978170ad1317fbdd6e0eab218405f218f34e44dca5124e2f5c","title":"","text":":/\nThat said, there must be something local going wrong, as the official (cross-build) armv7 compiler seems to work fine, at least with the same simple reproducer, e.g. . I'm going to try a fresh build on a fresh system with absolutely no local LLVM present...\nSo -- that worked, both beta and nightly. I'll make sure to update our distro LLVM patches. What tripped me up on nightly was that stage0 is still 1.17.0-beta.2, which doesn't have the LLVM fix. I bumped that to beta.3, and then it worked. This doesn't affect the official nightly builds because only the host compiler goes through stages, and AIUI the cross-compiled targets only use the host stage2. But doing a native arm compile, the bugged stage0 gave me an unusable stage1. On beta, I don't know what happened before. I think perhaps somewhere when I was jumping between local and rust-llvm and testing different branches, I must have gotten a build of the still-broken rust-llvm, with a timestamp such that rustbuild didn't think it needed rebuilding on the fixed sources. I still have that build directory tarballed here, so I may poke at it when I get a free moment.\nSo we should update 1.18's stage0?\nOK, see to bump stage0."}
{"_id":"doc-en-rust-ec93b61328c9666a771dcbaee01d4f3175b6dfc4cee7d2970ce7a3e072a48fa8","title":"","text":"These are all legal, and somewhat strange, since they're not really following the file-system analogy that modules are typically explained with. I expect this behaviour is just whatever happens to fall out of the current implementation strategy, so let's make a more explicit decision one way or another. As one might expect, each of these is a distinct instance of (which can be verified by placing in : the compiler will greet you 3 times). Noticed in .\nThis seems weird to me. I think the intention is that the out-of-line syntax () should only work at the top-level.\nI'd vote for allowing non-inline modules only at the top-level, to retain a clear mapping to the file system.\n(Or nested inside modules.)\ntriage: P-medium Backwards incompatible, but ... kind of a curiousity.\nFound one more mod aliasing scenario. It involves several files, and is semi officially allowed by the reference. The layout The files The copy module will be aliased. The problem is that although and are not directory owners, their inner modules are.\nUpon reflecting more about this, I think that there are two questions here. should non inline modules be allowed (syntactically) inside items? should module aliasing (the same file representing two modules in the crate) be allowed? The questions are independent because you can use attribute to create module aliasing manually. I would prefer if the answer to the second question is not. I'm contributing to the Rust plugin for IntelliJ IDEA, and one of the tasks there is mapping files to modules (for example, to go to the parent module). I would much prefer just to highlight module aliasing as an error, rather then to deal with non one-to-one mapping between files and modules. As a side note, if a user does want aliasing for some reason, she can always use symbolic link for the same effect.\nI tend to believe it is fine to have aliasing if you write the yourself (you asked for it...), and that it would be ok to put a non-inline module inside an non-module, if you specify the path yourself, but that we should error out otherwise. However, there has definitely been confusion in the past about the role of as a declaration and not a , and disallowing aliasing would prevent that confusion from leading to incorrect trees."}
{"_id":"doc-en-rust-13193e7d8cc7de52ca12bbee1c181886fde5ae3673cf0de803a8511204caf844","title":"","text":"however is disconcerting, and suggests that perhaps the code has a slightly different model in mind than I do in my head. :) That is, I strongly expect to (by default) be found at . What happens if you don't have the , but just place in ?\nIt is forbidden because is not a directory owner.\nJust in case here is a repository with the example: I don't see a reason to allow user to shoot himself in the leg. What if you accidentelly have identical attributes (copy paste problem)? My main concern though is that non injective file to module mapping may complicate the implementation of some rust tools. Here is another hypothetical example of this. Suppose you implement incremental compilation for rustc. You will need a mapping from files to modules. If mod aliasing is alowed, then you will need a multimapping. So you end up with more complex code which is used only in a tiny fraction of projects and because of this probably contains some bugs.\nAh, I see. So it seems to me that the problem is that should not be allowed in contexts where would be illegal. In other words, an inline module should only be considered a \"directory owner\" if it is located within a directory owner. A compromise might be Yet Another Lint Warning. ;) I agree with you about preventing people from shooting themselves in the leg, but I guess I think people don't use lightly or frequently, so this seems unlikely to be a major source of confusion.\nI totally agree that this curiosity is insignificant for users. But I still worry more about the implementation side of the issue, and a lint warning does not help here."}
{"_id":"doc-en-rust-1fb348516fce42735a2f7d856f66678c531adef3f524310c5b14170cbebf9cf5","title":"","text":"This erroneous code: Produces this error message It would be better if instead it produced an error message like this: Tried the code in these Rust versions and they all produced the same error message: 1.37.0 stable1.45.0 stable1.46.0-beta.1 (2020-07-15 )1.47.0-nightly (2020-07-22 ) <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThis shouldn't be too hard. This comes from the parser, specifically the code that parses a pattern, which is one of functions. Somewhere there is the code to parse a struct pattern. I assume the error above happens when it successfully parses a struct field and then expects a comma or closing brace. To fix it you'd have to check for and report a better error message.\nclaim"}
{"_id":"doc-en-rust-b3127c5b2931668785539d3dc2215a7dc0521bae0c64b183669c2615dbe4f6fc","title":"","text":"These are configured something like\nI am not sure why this happens off hand, but when bootstrapping the non-build-triple compilers artifacts are copied from e.g. to ."}
{"_id":"doc-en-rust-7cb4be169a5151d369f6cf74dd375d70b46cfdfbc058482a6c1153d7ac0e061c","title":"","text":"The test in leaks memory, which makes a Miri run of the test suite fail: Running Miri on the test suite is helpful to find bugs, so we should avoid deliberate leaks to still be able to detect accidental ones. Can the test be changed to use some other means of ensuring that is not called, e.g. with a type? Cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim I made the test I should fix it\nthanks. :-) Let me know if you need any help."}
{"_id":"doc-en-rust-314973a620198a343d95c6001fa5535e22745954ce83c0927d2a46bf1bfbe699","title":"","text":"With the following code: We get this error: Making the block then gives: cc\n:+1:, this should error in both cases but the diagnostics are misleading. Going to fix it. r?"}
{"_id":"doc-en-rust-2ba680042c318985d701aa42266b2b8497db2540f48bba18af768238f1d59d61","title":"","text":"Fuzzer generated MIR, reduced, and UB-free under Miri (for real this time :sweatsmile:) Segfaults with enabled: , which is a valid pointer, somehow got propagated as 0: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThat seems undesirable. Is there a surface Rust program that can produce this MIR? Asking primarily for prioritization purposes.\nWG-prioritization assigning priority (). label -I-prioritize +P-medium\nMinimized test case:\nHere's an example using stable surface syntax (). Seems to have been introduced in 1.70, with in particular.\nNevermind seems like I was wrong. <details</details\nIt's not an LLVM miscompilation, the code is already by the time it goes to LLVM. With So it's defiantly happening in MIR ConstProp\nThe problem seems to be that when running on the statement , the frames arn't updated, so when it runs on , it thinks is their for local . , on to add logging and test. ()\nclaim\nCc"}
{"_id":"doc-en-rust-90bd225a208b9bb471a32eda4959929a256e6fff107b5af48e291c8d9be22cb1","title":"","text":"root: yup-oauth2 - 360 detected crates which regressed due to this; cc <details</details\nI think this might have been caused by\nI can confirm that is the cause. Patch coming shortly."}
{"_id":"doc-en-rust-c438d696c89f75280a96a928a87418c7668d7e4550009afc60e99f248f7225cd","title":"","text":"Specifically at , and recommend for Windows too, right? We've , but in the meantime, the old book should recommend the new recommended toolchain :) If it's too soon to do this because isn't stable enough yet, consider this a reminder issue to make this change once it is :)\nwants to wait a bit, and we'd need to then make sure to update the website in sync (see )\nMaybe the big red warning \"this is beta software\" should be removed from the website?\nThis will be fixed by"}
{"_id":"doc-en-rust-c875271ee78e88cab7b1e6cbc7c7d8dd341d5e80e0bb8796a460c13ee15625db","title":"","text":"I was attempting to assign directly to the result of a vector's , which caused this error to fire. That is when I discovered that the help section was telling me to do add an extra let to my while statement, which is not syntactically correct. I tried this code: I expected to see this happen: The code would fail to compile and the help message would tell me to dereference the left side, or at the least give me code that was syntactically correct. Instead, this happened: The could failed to compile, and the help message gave syntactically incorrect code as seen in the backtrace section. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nThis minifies to which reports and are related I think, since this example produces the ICE mentioned there on stable\nlabel +A-diagnostics +D-invalid-suggestion +T-compiler\nclaim"}
{"_id":"doc-en-rust-8b1ec211d716abde8a5032848a1c07e72c861f3a97ce918fe4cba2c2cfea2625","title":"","text":"Basically just change this macro to recognize and discard the trailing comma.\nThat macro declaration is formatted in a weird way. But anyway it should be enough to add to the rule (unless accepting multiple trailing commas is undesired). I could mentor.\nHow about this:\nOut of curiosity, why doesn't rust allow trailing commas after automatically? Does it make it hard to write some macros? Alternately, why isn't there a (optional) repetition specification (e.g. would be 0 or 1 times)?\nThe extra rule is fine too. It's just more annoying (extra repetition). And there's no technical reason not to support one-or-none patterns as far as I'm aware.\nMade a PR :)"}
{"_id":"doc-en-rust-9efb448391e17c7cc2c5b7508a4f5840904130cac96cf2da07110367068af352","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 was likely introduced in (CC rustc 1.65 nightly 2022-08-12 emits the following:"}
{"_id":"doc-en-rust-51be287cc02c43fc8b21cffae7fbc673700aec4257cb92bf9bc4e15af1615313","title":"","text":"The error happens on latest stable and nightly. Steps to reproduce: ; : : returns error: The error only happens if the module is named (for instance, and work without error). The error is not produced if doesn't use in any way. If doesn't contain imports but uses the library directly (e.g. ), the error is produced. always succeeds. I don't know if this is supposed to be forbidden but the error message seems to be misleading.\nThe second instance is injected implicitly. The error could be better, yes.\nWhere exactly is injected - in the library or in the test? Why does the library work on its own? Why does conflict with in the test?\nOk, it turns out this is a legitimate bug, I misinterpreted it as a more commonly reported diagnostic issue. is injected into both the library and the test, but only the first one causes the error. If you set in , then you'll see the error immediately while compiling - conflicts with . On 2018 edition, however, is injected in more subtle way, as where is some unique symbol that still has the string representation , but doesn't clash with anything in the same crate. Unfortunately, turns into \"just \" after encoding into metadata in the compiled library (this is the bug). So, when we load that library from the test it looks like the library defines two conflicting items.\nThe solution is to either encode gensyms/hygiene into metadata properly (this is a large task and a long standing issue), or come up with some hack preventing the injected specifically from being encoded (it doesn't really need to be encoded).\nFixed in"}
{"_id":"doc-en-rust-4ca0e1ddefc7fb7468afc8b93eebb60c928e1406b90c27795c8b3cd68db8f0f4","title":"","text":"In a recent PR I made a change to unify the wording of multiple privacy errors, but : used to be This one change needs to be reversed while keeping the rest.\nHi! Could I give this issue a shot?\nI am sorry I forgot to claim the issue\nNo worries :-)"}
{"_id":"doc-en-rust-64078b2bce961079ae95e838f0de415ad1df6d73b4b0784edf1e2232442d09d1","title":"","text":"was closed when stabilized the corresponding language feature, but we didn’t realize that it was also the tracking issue for this standard library feature: History: [x] Original tracking issue: [x] Discussion of payload vs message [x] Making .message() infallible: [x] Split core/std PanicInfo into two types: This made core::panic::PanicInfo::message() infallible. [x] Use opaque return type: [x] FCP [x] Stablization PR: Unresolved questions: [x] Should it be infallible? Yes, by making std::panic::PanicHookInfo a different type. [x] What should the return type be? or an opaque ? The first is simpler, but the latter allows a bit more flexibility for future changes.\nInstead of making a PR go through the queue to fix the tracking issue, should we stabilize this method? fcp merge The doc-comment is slightly wrong or out of date. Its second line shoudl be removed. always creates a where is , regardless of the number of arguments given. In the single-argument case, that argument is required to have type . At first returning seemed unusual to me and I considered that we could make the method return instead, on the basis that calling its impl is almost the only useful thing to do with a . But has been stable and documented as the return type of since 1.0.0, so maybe it’s fine.\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [x] [ ] [ ] [x] [x] [ ] [ ] [ ] Concerns: single-arg core::panic () 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.\nThe module also links to that closed tracking issue. Let’s consider the pFCP above to also include stabilizing it. ( is stable.)\nconcern single-arg core::panic Should we change libcore’s macro so that its single-argument form creates a with a instead of one with a ?"}
{"_id":"doc-en-rust-25eef06e5513438ea83a2ce818db3dbca78deef5f357f7771ea0a66096ac6576","title":"","text":"CC Pushing this idea further, it’s tempting to maybe remove entirely and instead have a whose dynamic type can be . But that doesn’t work because is a method of and is not .\nI thought the point of the message field was that core can't make a payload since it can't allocate?\nThe struct is: Both the and fields involve borrowing. As far as is concerned, they could both be borrowing form a stack frame. (And as far as I understand they are, in practice today.) It’s in the case of unwinding that there’s an owned that can return, which requires allocating.\nBased on the timing of it looks like you may have thoughts on this :)\nAh, goes into how and why the panic handler in libstd (which is called by if libstd is linked) ignores the it receives. We could probably change this but it gets tricky: while most implementations of for environments would be fine with receiving a borrowed payload, libstd wants to potentially take ownership and box it for unwinding.\nI have zero recollection for why this is the way it is, and I'm not really particularly interested in doing all the archaeology to dig up why it is the way it is. I'm not a huge fan of just stabilizing things because they happen to be there, but I don't really see why we wouldn't want to stabilize this. If there were a reason to not stabilize this though an investigation would presumably turn that up, but I'm not up to do that investigation myself.\nThat’s totally fair. I’m confident that this was more likely forgotten than deliberately left unstable. If deliberate we would have kept the tracking issue open or made a new one for the remaining bits. This is what lead me to propose stabilization. Having dug a little more, and thanks to Ralf’s blog post, I think we may want at some point to revisit what data we expect to contain or not in various situation. In particular it could be interesting to extend to support payloads other than and make it closer to . Given those possibly-desirable changes, it may not be the time to add more constraints: fcp cancel\nproposal cancelled.\nLol, I had no idea. ;) So, indeed, I was wondering if we could do something about the duality of the and fields in . I assume we cannot change the fact that the same type is used both of panic handlers and panic hooks."}
{"_id":"doc-en-rust-928e4cd082453c51abb233b033d4d88ce4bfbacacb0004ddc46fb7251f46f38e","title":"","text":"Concretely, I was thinking of adjusting somewhat like this: That would at least remove the need for the hack in . (The hack would likely move to instead, but that is a smaller hack IMO: the hack is now not encoded in the state of any more, just in its dynamic API.) I think this would retain all current functionality while clarifying the invariant of wrt. the payload (and explicitly calling the message a \"payload\"; right now it seems to be something that sits next to the payload which is inaccruate). But there are enough subtleties here that we'll only really know once someone implements this. With this change, the panic hook would always get a . We should likely provide a method somewhere in libstd to factor out this code: I was imagining something like an extension trait on with a type like . However, the panic hook is not the only place where that conversion is useful; another situation is code that caught a panic and wants to extract the message. I expect most instances of that to just handle payloads, not knowing that payloads are also common (that is certainly what happened when I wrote such code). So ideally we'd have a method that takes and returns , but I do not have a good idea where to put that. This is the hard part, as we cannot use . I wonder if we can use a take-based approach, similar to ? Conceptually, would put the panic into an , and somehow pass an to the panic handler, and the implementation of said handler could then the payload if it needs full ownership (like for unwinding). Except the panic handler cannot be generic, so it would have to be , which is not a thing. But with enough unsafe code we could re-implement something that behaves like that. I don't see any way to do this entirely safely; the panic handler that wants to take out the payload and put it somewhere needs to dynamically determine the size of the payload and arrange for there to be enough space. In liballoc, we could provide a safe wrapper for this that puts things into a , but in libcore, I don't think there is a safe API that we could provide to grab ownership."}
{"_id":"doc-en-rust-86b2c8da8c5c6984f78aa5d946a63acf7bba6ccd5b4f5ecdc4bafd4ce7e60c32","title":"","text":"But maybe it is enough for the public API to expose ways to borrow the payload (should work for all non-unwinding handlers); if only libstd needs to take the payload (for unwinding) we could keep the unsafe part of the API internal. Also, we certainly do not want a panic hook to the payload out of its . At this point it seems to be quite a problem that panic hook and panic handler both use the same type. In fact, a panic handler likely wants a to be able to things without interior mutability. Is there any way we could make the attribute support both signatures, and then (based on the types of the methods) only -based implementations will actually be able to or the payload?\nI agree, but it’s can easily be an inherent method of nor of because those are in libcore which doesn’t have access to . It feels slightly unfortunate that we’d need an extension trait just for this. I considered this yesterday and come to pretty much the same conclusions. To take ownership of a payload of unknown size through a non-generic API we pretty much heap allocation, which for libcore means something like receiving an , unsafely using , and returning that is to be passed to . It’s not pretty, but if only libcore and libstd deal with this internally maybe that’s ok? Is there a use case for a other than libstd’s to take ownership of the payload?\nI was thinking of a slightly different API actually: Here, does to put the payload into caller-allocated storage; that storage must have (at least) size and align as given by . What I did not consider is how to get out the vtable, so maybe that higher-order approach is better.\nWe discussed this in the libs-api meeting today. We concluded that before stabilizing this, we need to make sure it works (doesn't return ) for std::panic!() as well. That is already the case with Rust 2021's std::panic!() (since it's identical to core::panic!() in this edition), but not for Rust 2015/2018's std::panic!(). Once that is fixed, we feel okay with returning a placeholder message for non-string panics (panics from or Rust 2015/2018's ), at which point the function can return an unconditionally, rather than an ."}
{"_id":"doc-en-rust-4a89d36630d834ba38cdfcc5cd7802c94f943d601d14ea3f278db75c486d0db3","title":"","text":"(And also, should be returned by value, not by reference.)\nAny progress on stabilization?\nIt would great to have this little feature.\nStill nothing? What's missing?\ncan this be stabilized after was resolved in the pull request ?\nYes, soon, hopefully! I've updated the overview at the top of this tracking issue. The main question left before stabilization is the return type of the method. Should this return (as the unstable method does today), or should it return an opaque type that wraps that fmt::Arguments, so we can still change in the future? (In case we want to support different types of no_std panic, such as panicking with an Error or something.)\nCan it return or so?\nI would vote for an opaque type that would also implement .\nDid that in this PR:\nmerge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [ ] [x] [x] [x] [x] 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-9eeaaa7acbac320ad451a6095a00086a3e46c7d3f164983cd5c4a0b060c733ad","title":"","text":"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\ncc removing the println macro from around the match avoids the ice :thinking:\nFun :)\nA more minimal version would be:"}
{"_id":"doc-en-rust-f0a7e9ef309afa13524b79e1e4eb6b2936bb23e506865eeeb3c4450a51ecd325","title":"","text":"On identifiers that have more than one word, it is relatively common to write them in the wrong order ( → ). These are normally not found by Levenshtein distance checks, but we could do a basic \"split on ``, sort and join before comparison\" so that we could suggest the right identifier. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nI'd like to try to work on this. As is short enough to be caught by the Levenstein distance, I wrote for testing: claim\nI'm thinking about the priority of the different possible matches. I tend to think that a match found by levenstein distance should have a greater priority, but what do you think?\nit's tricky. I feel that your instinct might be right but we'd only know when looking at real world usage. The nice thing is that the lev distance check by its very nature it is limited, so doing the swapped words check as a fallback should work out ok in practice.\nReleasing my assignment, as I am not sure to be able to commit. In case someone want to take on this, here is the function that should be modified. release-assignment\n(I think this is appropriate, please tell me if it isn't) modify labels to +E-Easy\nI can take a stab at this, seems reasonable with previous comments. claim"}
{"_id":"doc-en-rust-f200ad873b00cfa4840a124bfec92ccb868dab6f8efad02f28ec3a1c24a65654","title":"","text":"According to , the standalone tarball installer of stable Rust releases includes Miri. That's a bug, Miri is a nightly-only tool and should not be shipped on stable. Cc\nPosted a fix at ."}
{"_id":"doc-en-rust-5d190640d84d49b3a73bc3761a12d17475baedab4bed3cc1bd2c12961072670f","title":"","text":"Happens on WIndows 7 x64 with latest Rust 32-bit nightly. : (On a side note, is there any way to work out what the latest released nightly version is?) : Compiling with produces: is there to suppress the warning, can be removed if you compile the rest as a library. Also works if you substitute the expression for directly and if you pass two arguments (the original use case). The original intent was to tell if two s were identical as a sanity check.\nCan confirm this still results in an ICE.\nTriage: still ICEs.\ncc rust-lang/rfcs\nfixed this.\nI'll add a regression test for this"}
{"_id":"doc-en-rust-35378ae24f994e1e82d353e3a09b882a3441c1abf89a5104c23d1fb33de146fb","title":"","text":"<details<summaryBacktrace</summary</detailsWindows 10 (64-bit)\nWhich code had caused this assertion? Caused by this assertion: Which was introduced in , which is beta-nominated. cc\nI'm glad I that assertion! What it likely means is that isn't a multiple of . I'd be quite surprised if and/or weren't involved.\nIn my case this error is caused by the crate. Simply including it in your and compiling crashes rustc. <details<summaryBacktrace</summary</detailsI'm on Arch running the latest nightly rustc.\nLooks like triggers the assertion, and it has alignment but size (which is illegal), IIRC, includes some types that are ( this is indeed which has a packed ) and has caused issues in the past as well. EDIT: minimal repro:"}
{"_id":"doc-en-rust-6ebc6bcbbe025216226a076c9bb7935562c895f3554d0f8ba1bd87c3a0a550a0","title":"","text":"When setting the directory to persist doctests to if an UNC path is used on windows there's a segfault. The offending setting of persist-doctests: . cargo-tarpaulin sets this programatically using a path it gets for the target directory from cargo-metadata. The path from cargo-metadata is an UNC path and this then causes a segfault. I'm going to detect UNC paths in my code and remove the on windows, but I felt this warrants a bug report as someone else will hit it eventually. Also, I'm not sure if other parts of the compiler fall prey to this issue? Compiler version is: the latest nightly (1.64.0-nightly 2022-06-28) The stack trace: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nThis panic is also triggered in Linux if e.g. trying to write into a directory that the user has no permission to write. I PR'd fix to change the unwrap to more orderly panic and relaying the underlying error detail via eprintln! ~/gg/rust/build/x86_64-unknown-linux-gnu/stage2/bin/rustdoc --test -Z unstable-options --persist-doctests /tmp/foobar Couldn't create directory for doctest executables: Permission denied (os error 13) instead of:\nThe lack of ICE is definitely nicer, but this still won't handle UNC paths on windows will it? Which is the main issue I personally have with the code\nThat's a problem for std::fs::createdirall(&path) me thinks has to be fixed there\nMakes sense looking at the code, should I raise another issue for the libs team?\nActually, yes it would be great to raise another issue targeting std::fs::createdirall - as it is wider issue. you are right. Thanks!\nSo isn't this an issue with the tool generating an incorrect argument?\nSo the paths are weirding me out (I normally only use linux), because they seem to sometimes print differently given different display methods. It shows up as printing the path in my rust code before making the env var, and if I print the rustdocflags I'm setting it's correct."}
{"_id":"doc-en-rust-396633b09f39f3fda583cc64f30ad5d9a26777e5093cc4eb5e4203fef70ab275","title":"","text":"But if I do it returns false, I have to do for it to return true. I'll raise the other issue and after work look into it more properly try to make a better MRE for windows\ndo you mind changing title s/UNC/invalid/ to address the panic on this issue, thanks! :)\nalso please remove s/on windows// thanks a lot :+1:\nDone, and I realised what was wrong with the path, it's correct in the code, it's just when it got set into the environment variable it seems it needed the first slash to be escaped and that caused the invalid path (so no issues in std::fs need fixing)\nclaim label +I-ICE +T-RUSTDOC"}
{"_id":"doc-en-rust-f899d2cebd9cea0e8e2409b042db9515642171e1f8f203c81028265ec547bca3","title":"","text":"STR (on Linux): file that has generics usage () code DWARF info Notice that contains such entries as , possibly produced by the fact that \"\" is a relative path and DWATcompdir is set to \"/home/yury\". It is expected for core files to have absolute path e.g. \"\"\ncc I wonder what interaction (path rewriting?) causes this result.\nFWIW, produces that shows that !DIFile entries has the directory field empty (and the filename is relative)\nIt is a regression, since +stable has absolute locations, e.g.\ncould this have to do with\nLikely so! I'll try to look into this in the near future\nOk so the change here can be exhibited with this script: If you execute that script you see: but if you remove you see: It appears that if upstream crates (like libstd) use then their filename is listed as the original relative source file instead of the absolute path name that it had previous to when it wasn't compiled with . So somehow using to compile libstd is affecting downstream crates to have relative path names instead of old absolute path names. It makes sense to me that the absolute path name goes away with (that is the whole point after all) but ideally it'd still be an absolute path, just applying the mapping. would you be able to help point me in the direction of where this change in logic might happen? If so I can test out a patch!\nThis should be what you're looking for: One solution would be to compile libstd with absolute paths and apply proper remapping to those.\nAh that's perfect! I'll see if I can work up a solution to that soon"}
{"_id":"doc-en-rust-873bf10379b4caf187ed69a684f0180f6cd1d81ef25e103ed58fe8de2dca7fde","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) (original) <!-- If 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 --\nPlease try to minimize the example as much as possible:\nclaim\nheads up that already put up a fix\nThanks Just want to add that some other intrinsics also ICE. For example: ICEs as well.\nInteresting -- I wonder if we should perhaps fix this in a less specific way than . I wonder if we should instead detect that the declaration is not valid b/c has not been enabled in the crate... If not, then I'd be glad to review a PR that fixes whatever other intrinsics you find to make too many assumptions in the compiler.\nEven adding does not prevent the ICE unfortunately. It happens in due to the wrong number of arguments e.g. here for : occurs for a lot of intrinsics in this file. I'm guessing all of them will ICE under the conditions in this issue. To fix it, we could extend what's done for in to all intrinsics, maybe leveraging this code to know how many args are expected for any given intrinsic:\nI have opened\nLooks like intrinsics are expected to ICE if used wrongly (see comment: ) so I opened has been rightly closed. But that mean that should also ICE in these conditions. However, in the present issue it was ICEing for the wrong reason i.e. out of bound access . So does the right thing by stopping that. However, IMHO it should not taint the context and let it go to MIR lowering and then let it ICE there. That keeps consistent with other intrinsics' behaviour as noted above. Thoughts & If you guys agree I can open a PR to remove the tainting.\nSee which takes a different approach\nNice!"}
{"_id":"doc-en-rust-c282fe6f824553e09f5c07f952e15a0f99ec40e81067648f5354d54898abcfc1","title":"","text":"When encountering a , there must be a corresponding in the MIR body. If there isn't, later passes can panic due to indexing out of bounds of the array. The validation pass could detect this problem earlier. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nInstructions: Extend the validation pass in by implementing for the MIR visitor: The trait is documented . The method should check that the local exists in , and fail with a descriptive error message if not (by calling , not by panicking directly).\nclaim\nFYI, the validation pass currently fails on even libcore until is merged, so you need to either wait for that, or cherry-pick some commits from there to get it to work. You can test your changes by running (the validator only runs on very little code by default, turns it on for everything).\nI wanted to double check, running should fail when I run it, right? It actually passed for me after I merged in your branch from I wonder if I should try clean and build stage 1 again. :\nIt should pass with applied, but fail on current master.\nSo your PR fixes this issue () as well?\nAh, no, this issue is just about adding additional validation. It shouldn't actually detect any locals that don't exist. So the command should work both before and after implementing this. If it fails after implementing this, something else is going on that we should look into.\nare you still working on this?\nNo, sorry. Didn’t have time for it. Go ahead.\nrelease-assignment\nWould like to work on this, but it seems there is another check, not on the declaration like this one, but on the memory liveness. This should cover the case that the local is not declared (I think), or would it not?"}
{"_id":"doc-en-rust-c91419fbc9c04efe0ce4be4b9a1c1145472a60c982af690f2dc42c14c5466c93","title":"","text":"This is intended to be a tracking issue to incorporate into the current beta branch for the Rust 2018 release, as we'll be relying on that in documentation that we're writing.\nThe Cargo backport is happening here - , and after that needs a PR to the beta branch in this repository\nThis is now submitted as\nDone!"}
{"_id":"doc-en-rust-8ee58d94fa0ef584ff51898c2e18b4f6db9d2a2f8a32ce61c15bd0598bc08be9","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: /// let example = Example::new() /// .first(\"hello\") #[cfgattr(not(feature = \"one\"), doc = \" .second(\"hello\")n\")] /// .third(\"hello\") /// .build(); /// with I expected to see this: ! 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. --: running over the code gives me /// let example = Example::new() /// .first(\"hello\") /// .second(\"hello\") /// .third(\"hello\") /// .build(); ///\nAs explained on discord, <strikethe attributes aren't applied to doc comments</strike(EDIT: they are applied, the problem seems to be that it results in two doc comments for rustdoc). However, your doc comment is split in two so the second half isn't considered as being inside a code block, explaining why you have this display. Even if shows it as one doc comment, rustdoc sees two of them. <strikeMaybe we should add a warning or something that attributes aren't applied to doc comments... What do you think ?</strike\nHow can an attribute get applied to a doc comment? Both are, under the hood, attributes, no? I would expect that to be equivalent to expecting to only derive Debug if is passed, which is not how that works. I'm guessing what is true is that attributes directly written don't actually merge with -style comments. Potentially relevant: , ,\nSimplified reproducer rust //! foo(); #![doc = \" bar();\"] //! Checking with 1.31.0 it still ignores it (so likely not related), but checking with 1.21.0 (and 1.0.0) it worked as expected, so somewhere within that range (but I don't have any other versions installed at the moment to check).\nCompilation broke somewhere between 1.23.0 (works) 1.24.0 (does not work) I tested it with rust //! let x = r#\" #![doc = \" bar();\"] //! \"#; //! assert_eq!"}
{"_id":"doc-en-rust-22025efa542aca0f5d1e1cb64dd2a9fb6827148d35b2d19fd6f299aa237bd882","title":"","text":"(x, \"n bar();n\"); //!\nThey are not supposed to be applied to a doc comment I do not think that. Your example would make sense for which I also consider to be wrong, but I am talking about which should insert the attribute conditionally but that is not the point. It might help to illustrate my thought process; We have some kind of documented item: rust /// let example = Example::new() /// .first() /// .build(); /// and each of those is turned into a doc attribute rust\"] #[doc = \"let example = Example::new()\"] #[doc = \" .first()\"] #[doc = \" .build();\"] #[doc = \" In a later step those attributes would then be concatenated and parsed as markdown or whatever. I want to use this behavior to document items conditionally, depending on which features the crate user has enabled. One way to do this would be to do rust let example = Example::new() .first() .build(); rust let example = Example::new() .first() .second() .build(); but that would blow up the source code with many duplicate lines, where only some minor things were changed. So I thought that it might make more sense to conditionally include a doc comment like this: rust /// let example = Example::new() /// .first() #[cfgattr(feature = \"one\", doc = \" .second()\")] /// .build(); /// which would turn into rust\"] #[doc = \"let example = Example::new()\"] #[doc = \" .first()\"] #[doc = \" .second()\"] #[doc = \" .build();\"] #[doc = \" or rust\"] #[doc = \"let example = Example::new()\"] #[doc = \" .first()\"] #[doc = \" .build();\"] #[doc = \" depending on whether the feature is enabled. So the attribute should not be inserted and not applied to the following doc comment. The weird thing is that the manually expanded version is working as expected. rust\"] #[doc = \"let example = Example::new()\"] #[doc = \" .first()\"] #[cfg_attr(feature = \"one\", doc = \" .second()\")] #[doc = \" .build();\"] #[doc = \" but this is very unhandy to work with :/\nI was randomly looking at passes for another reason and noticed what is likely the source of this issue."}
{"_id":"doc-en-rust-1752a6e17bff6c1bf51268c99b83180f71349486ca505e2423f24df04e392292","title":"","text":"There are two relevant passes: runs second and removes leading columns of whitespace from the docs. This runs on a single \"doc fragment\" at a time, because of merging that normally means the entire documentation string, but since sugared and raw docs aren't merged they remain as separate fragments and use their own widths of leading whitespace to strip.\nThat also matches up with first released in 1.24 which introduced this distinction between doc kinds in order to fix , which IMO was user error in not matching the indent depth."}
{"_id":"doc-en-rust-22fb7b6f67d45384b76cb98f00c2c9bb1eb60397fdda5039e6272ede7ca75a41","title":"","text":"The idea of shortening to has been discussed many times before, and the general consensus always ends up being that it is not a good idea. I would like to propose something a bit different, so please hear me out. I propose that instead of aliasing to , we instead just make expand into when in the context of a variable declaration. For example: This solves the problems (readability, more concise) that people have with , whilst not causing the issues that people have (pattern matching and consistancy). The most common issue people have with aliasing to is that it doesn't fit well with patterns, like . However, gets rid of this problem, because you wouldn't write if you were trying to pattern match, so why would someone want to write ? You wouldn't do that, and it wouldn't compile. This would be optional, of course. would still work fine, and people would just have to option of removing the to let it be implied. There are a lot of other abbreviations used in rust (, , ) that all serve the purpose of writing less. It just doesn't feel right that one of the most commonly used keywords is so long. :heart::crab: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nRust wants to make to make you think when you try and use mutation, even if only a little bit, because mutation can be difficult to reason about. Shortening to doesn't fit this philosophy. Also, this makes mutation just as easy as no mutation. This will lead people to choose mutation because it will give them less compiler errors in the short term, and in doing so open themselves up to some weird bugs that could have been prevented with the syntactic salt that is . tldr: wasn't rejected because of the name , but because it allowed easy mutation, which runs counter to Rust's philosophy.\nI politely disagree. In fact, it is actually the other way around. Using unnecessarily will cause compiler warnings, discouraging the use of unneeded mutability. The compiler doesn't warn when the use of is actually needed.\nThe fact that people will choose in the face of compiler warnings has been shown in practice, across many projects."}
{"_id":"doc-en-rust-b9154840b0c9d060fd899679bd57e8e1ce763b6d8cb627673ab7e602eb919575","title":"","text":"Also, the problem isn't that people may choose to put just for the heck of it, but that they will unintentionally mutate something that was supposed to be immutable. And because it is being mutated, there is no warning, and they used because it is their default, it is their default because it gets rid of compiler errors that say they were trying to mutate things that are immutable even though they weren't supposed to mutate them in the first place. They will use because it is just as easy as making it immutable. So the problem is a bit more subtle than you seem to think.\nIncorrect. Extreme brevity harms readability. See Perl. lol Readers would ignore the vs distinction far more often that vs , partially due to length difference, but works even better than say . It's true boilerplate often harms readability, but boilerplate requires some complexity be repeated, not merely the in . It harms readability even further if also works for , especially when you consider code readers need not actually know Rust. Rust syntax was designed largely to reduce cognitive load, not to reduce typing. We use , , and , not any shorter alternatives. And delegation RFCs have kinda given up the short syntaxes. I think Rust's omission of is now considered a mistake, but presumably helps C programmers. Rust has short keywords only really for fundamental \"items\" used repeatedly by basically every module. It's similar cognitive load if you write , , or , but actually just writing the shorter bare increases cognitive load. I think invokes the minor linguistic subtlety that variable means mutable binding, while acts like a common term for binding, which makes very slightly clearer.\nThe statement would be orthogonal to the current language in some sense though. is not a special syntax, but is composed of statement + pattern. It is in line with other places expects a pattern, where you can write , , or .\nIt seems unlikely to me that we would support as a short-hand. I'm personally opposed to it both because it adds unnecessary compiler complexity, stylistic schisms, and for the reasons outlined by However, I've taken the liberty of reusing this issue towards improved diagnostics: The idea here is to check . The idea here is to check: The relevant code is here: cc\nclaim\nError: Parsing assign command in failed: claim :)... Please let know if you're having trouble with this bot."}
{"_id":"doc-en-rust-4829c79c562ba0692e23bb060acaea94e3d3de85d8e68989c7b6a6d88f0d655d","title":"","text":"Although I would also guess that the initial idea is very unlikely to end up accepted, it feels premature to unilaterally hijack the thread in your very first comment and make it have a different (and in a way opposite) purpose. Teams of the Rust project are designed to make decisions collectively. Improving diagnostics sounds good, but issue numbers are cheap.\nImplementing something as a diagnostic actually brings you closer to a working implementation -- I think more proposals should start out as diagnostics. I will not bother the other language team members with not-fully-formed proposals that we will not accept in either case. I converted the issue into the most actionable and productive thing it could be. The place for ephemeral discussions is either on Discord or on internals. If you want to discuss this further, I'm available at Discord (but will not respond to it further here). wasting everyone's time with things that will go nowhere (because it won't be accepted and because it is not important enough to be raised at the team) is not.\nIMHO, the original thing this issue was opened for should be an RFC, not an issue. I'd have closed this, pointed the OP to the RFCs repo, and opened a new issue for the diagnostic issue.\nThis issue was literally in the RFCs repo initially, transferred it from there.\nLanguage bashing is not welcome here\nWait, so should I unassign here, and assign to the new issue?\nNah, just use this one.\nYeah, thats fine. You can just change this issue to be for diagnostics instead.\nI'm sorry, I've been pretty busy with coursework, and I'm still fighting my Python installation to even build the compiler, let alone make progress on this. Sorry :(\nI'll assign this to myself to work on when I have time. If you want to work on it however, feel free to work-steal it from me!\nI would like to help with this\nSorry; should have updated this issue...! There's a PR at the moment. Feel free to leave suggestions on it if you like. :)"}
{"_id":"doc-en-rust-71aa7ed432d18f41ff8723cba00d49e8197c8ceaa99f0b1969d95705049f17b3","title":"","text":"From The following code should be using the common list parsing utilities: CC\nWhat/where are the common list parsing utilties? Edit: never mind, I've got it. , , etc. for anyone who's wondering."}
{"_id":"doc-en-rust-6a2cbe7b8ccaca3ef9902b22c882856e408eb4eb39ba56ac69f0a1277306eef2","title":"","text":"I tried on Rust 1.76.0: I got the following error: Note that the suggestion has stripped the leading character from the enum's name.\nCan confirm this is still present in nightly.\nSounds like fun. Taking a look.\nSo it is intended this way from what I can see in the source code: Improving the wording would be become to clear the confusion though I think."}
{"_id":"doc-en-rust-bda38063fd04cfd297454e6b95c744ef9d7bf26d37e0fb497bb1d5fbe61aa6d2","title":"","text":"I'm trying to use on project generated by and looks like the source code path is not configured:\nVisited during wg-debugging's triage meeting. We think this is most likely still an issue but probably not a high priority one. If someone wants to work on this, the first thing they should do is retest and verify this is still broken (but we think it most likely is). There may be a fairly simple resolution to modify rust-gdb to detect which toolchain it's being invoked from and then run the set substitute-path path with the appropriate paths. I'm willing to help mentor someone in fixing this\nHi, I'm looking for a first issue, would love the mentoring!\ncan't reproduce it, it works just fine nearly 4 yrs later, has this perhaps already been fixed ?\nPast should have included a sample test case.\nNo, I can still reproduce it. are you maybe using a distro-packaged toolchain? Crashing program: output: To make work, don't use in the replacement."}
{"_id":"doc-en-rust-fc6afe71f34b34298ef431e453e55cb14f8d1fbdffb15c8f1a8e566b1318fe62","title":"","text":"When running , this file is opened for me . I thought I'd use that file in my note taking application, which I have set to a dark theme. However for in that documentation is set to have the and the background uses the default color. This leads to the text becoming hard to read. ! I would prefer the text color not to be explicitly set, or if you insist on the dark gray text, making sure that the background color is also set to something light.\nTransferred to rust-lang/rust. The CSS for this lives at\nIt's not rustdoc so to speak. I'll fix the issue."}
{"_id":"doc-en-rust-749b2a39e3587addcd49eae214863ecc634dee05f8269bc4babf97bcfde394f8","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. --: This bug was also reproduced in the stable version(1.72) <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nHmm this was caused by cc\nclaim"}
{"_id":"doc-en-rust-0c9a663f4e940747818f3bcec94601ab8f730d5e99e45ac40f235a7e1d510399","title":"","text":"The following code will fail to compile at \"Self::new()\" with the message, \"error: failed to resolve. Use of undeclared type or module \" While either of the following will work: The first example should compile as-is."}
{"_id":"doc-en-rust-d81fef094d84f0fd8d900d3ce12affe474dcc5b50ff6c9e65aaf1d069ba2cb71","title":"","text":"is a keyword, this error message indicates that it can be used to define type, which is misleading.\nThere is a similar issue: file.\nNo, that's a different issue. At the time that issue was filed, was not a keyword, just a confusing type. That said, at the time that issue was reported, it's fine to say the compiler was implemented properly. But my issue is about wrong error message, not bad(confusing) error message.\nDo you mean is not a special ident now? I found the example code can be compiled, and there is excluding self type code\nMy point is that we are in different situation now. See and notice that it happened after the time the issue we discuss was filed.\nActually, IIRC we're moving towards a direction where can be used everywhere in a trait or impl context. I'm not sure though. any idea?\nYes we can use it in traits or impls. is totally legal for instance. But inside global functions can not be explained if I understand correctly.\nOh, sorry, this was a global fn. Makes sense."}
{"_id":"doc-en-rust-4c32d76909af6d657706f93ddbdf5ec3d4e7b06aeb117374a46046d9ebb917dc","title":"","text":"Consider this code: The error is: It'd be nice if the explicit ref wasn't required in this case.\ncc\nThis has now been fixed.\nI believe this is covered by"}
{"_id":"doc-en-rust-c8c31d0935bfad6453ca56a52ce12aeae4d8a710911d54dfc638be37cf0f3959","title":"","text":"A documentation comment like the one cited verbatim below, produces a main page summary that includes the first line of the code in the example. This is very surprising since there's an empty line in between, and the code example inserts a large colored box in the overview page (the parent module). cc since it's probably related to PR /// A tuple or fixed size array that can be used to index an array. /// /// /// /// Note the blanket implementation that's not visible in rustdoc: /// !"}
{"_id":"doc-en-rust-a286439ec637b6a7e4cb759b48a2616bb0696b1ec7771f286f775eb9bc9b74ea","title":"","text":"I will like to fix this. What should be the better warning message here? Or I just need to remove the last sentence?\nIt seems fine to just remove the sentence.\nFixed by"}
{"_id":"doc-en-rust-c0445baba96251a26ba2bd1ecf284911efe69335324ddd4948077a60dc0402e0","title":"","text":"This is while debug printing all mir statements of libcore.\nmodify labels: +A-mir +C-bug +requires-nightly\nThis also reproduces on .\nThe incorrectly assumes at several places that the allocation kind is always what the type should contain. It for example assumes that an value always points to a function, and always points to raw bytes. It also ignores relocations at several places.\nTriage: I think this ICE is fixed by , no longer occurs with the latest nightly. Marking as E-needs-test."}
{"_id":"doc-en-rust-a0d841bfb922b96c26347299dc96ee914cac723edf5486bd909ad6487c2e2dde","title":"","text":"Minimal reproducer: Make sure to run rustc with to reproduce! Using doesn't fix this.\nMinimal repro:\nOther failure with code causing the above problem: This one is observable by printing the whole mir using , unlike the other, which requires you to debug print every statement.\ncc\nThat second one is a miri assertion: Interestingly, there's an afterwards that would be more helpful if it were before: cc\nIt seems like no longer ICE with latest nightly, I guess fixed this (CC: Marked as E-needstest\npoints out hasn't been fixed yet, dropping E-needstest.\nIs the issue description still accurate? \"Can't debug format a mir stmt in DefId\" reminds me of a after we had some ICE issues with debug-printing DefIds. But as far as I can see, no example mentioned here even triggers an ICE with that message. The ICEs described here sound very different than that, they look like CTFE is not handling ZSTs properly somewhere.\nI cannot on beta or nightly, so it looks pretty fixed to me. can you still reproduce this issue with latest nightly? The first backtrace has no code, so it is impossible to debug; the second backtrace (the one with self-contained code) does not seem to ICE any more.\nUhm? I don't think so, did you run with ?\nAh, I just ran on playground. It would be good to have up-to-date reproduction instructions in the first post, and not just in the third post below a huge stacktrace.\nYeah, but I don't have write access :/\nOuch, sorry. :( I didn't know. I will update the OP.\n<details<summaryHere's a backtrace with debug info</summary</details Looks like the is wrong.\nTriage: I think that ICE is fixed by , no longer occurs with the latest nightly. Marking as E-needs-test."}
{"_id":"doc-en-rust-503890be3917c660f6f5f2ae636b92b174b51b9e95a8c3581cc72939ff812c94","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!\nSure, I can look at this one.\nThanks for merging ! If I'm reading things right, I think I need a new crater release of it so I can update ? If so, can you please make one of those?"}
{"_id":"doc-en-rust-a48c513119b7cc694de9083a41db19b09972c37e0e9d47da7e1e4326cafd2fc8","title":"","text":"` The problem here is that we have instead of The compiler however points towards in the error message instead of the superfluous : Fun fact: when using four dots , it correctly points at the last dot :) <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nseems like a simple issue to fix. If I were to take a shot at fixing this, where would I start?\nMentoring instructions: Add a branch after this one... instead of , check that . This should be interpreted as a as in the previous branch, but an error should also be emitted. (Add the code for error emission in a separate method, with an appropriate , where the span of the is replaced with . See for an example on emitting an error with a suggestion.)\nSure thing! Will get to it right after work. Thanks for the pointers.\nassign"}
{"_id":"doc-en-rust-6f4363a60ee42a8d7dfa81c0b742aa8eb64a04a914b15145776cc0e885c53908","title":"","text":"Bisected to a rollup, but I think it's very likely to be . cc searched nightlies: from nightly-2021-10-01 to nightly-2021-10-19 regressed nightly: nightly-2021-10-02 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 old suggestion was actually incorrect because it suggested , which is a private import. However, the new error is \"more incorrect\" IMO since it says something confusing (and incorrect).\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium"}
{"_id":"doc-en-rust-fab3ca8c9179b639d7db0f30758e18fd05d791de7fbda0ef99ca6ccdc52995f6","title":"","text":"Const generic defaults are being stabilized, <!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nSeems to also happen with closures:\nI got a fix for this one I think. claim\neven worse, this compiles on beta but shouldn't\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-critical\nI think this needs to remain open until the fix is beta-backported :thinking: not 100% sure on procedure here\nYou might be correct. At least that's what happened last time one of my PRs was backport nominated (), though I'm not sure if that was due to that being a regression on stable. Regardless, thanks for reopening this.\nthat's my understading, too. I /think/ issues that are pending a beta/stable backport (like this one) will stay open until the corresponding backport PR has landed. The {stable,beta}-backport procedure is detailed but this detail is not explicited (I'll see if I can fix that to be more clear). For completeness, backports are discussed every Thursday during the compiler team weekly meeting (). Anyway, thanks a lot for fixing this issue and also to + for reporting and debugging :)\nCopied from Zulip: Question/thought: Is this a case where tracking bound vars got in the way? Or did it actually help uncover a potential bug?\nNot sure what you mean. The bug was that we were just not doing lifetime name resolution at all on const generic defaults. Like this code compiles on beta: edit: ohhh, you mean ?"}
{"_id":"doc-en-rust-da4b543757f0f59cd2c68f75eec2130e5847519474f60ca31783db1ed199f8fc","title":"","text":"Yeah I think in this case it helped uncover the bug, because of the fact it ICEd and showed us we weren't resolving the closure default.\nI guess this example shows that this did help us uncover a bug, but kind of indirectly: This just didn't uncover a case where \"lost\" bound vars.\nthis is now fixed on beta"}
{"_id":"doc-en-rust-381ae64d6501835356d822025536ad50a25cf2598179158099e24a3fc7856415","title":"","text":"Rustdoc now allows us to use in our tests. Unfortunately, this requires writing the manually, which really shouldn't be needed IMHO. So we now have to write: rust ///# fn main() -Result<(), (){ /// let foo = Ok(1usize); /// assert!(foo? 0); ///# } /// where it should suffice to write: rust /// let foo = Ok(1usize); /// assert!(foo? 0); /// Doing so will make the tests shorter and hopefully lead to more and less in tests.\nFeels like a no-brainer to me; would be great. :)\nI think there are two things we want before doing this: , so that it can always be , and existing code will just work. The re-do, so we can make a type that accepts any error type (since it'll just error anyway).\n?\nYes, that's what I'm thinking, and I'm setting up a PR for that. However, it's still unstable.\nI talked about this back in March on the \" in main\" tracking issue: That sample you gave isn't even valid as-is, unless coercing to is also in the pipeline?\nThat'll be next, hopefully. I wonder if it suffices to or if we need to keep a generic error type (which might mess with type inference). In any event, having both the aforementioned and should be a no-brainer, right?"}
{"_id":"doc-en-rust-a3939102936a3f2e2fbff182a7b08579aa0201acb625f2344aed49ebf726bfcd","title":"","text":"I need to give a Rust slice to a C API that will return an opaque handle (that actually contains a pointer to the slice), and the slice must outlive the handle. nicely suggested using for this, but the description of phantom data (and its RFC) for me is so far removed from my mental model/terminology of the problem, that it . \"…tell the compiler about fake fields\" — fake field doesn't sound like a thing I want to create. I'm not sure if a fake field is an actual Rust concept. I'm hoping it's a different way of saying a \"pointer that Rust isn't keeping track of\". \"inform the compiler that one or more instances of the type T could be dropped\" — but does it actually drop anything? I want to prevent value from being dropped, so this confuses me. The RFC is even worse, since it uses type variance terminology which is so confusing, that the most comprehensible description of them on Wikipedia is a 3D cube! !\nallows you to describe that a type acts as if it stores a value of type , e.g. maybe one is having to use opaque pointers or otherwise disguise the fact that there is a contained in the value, or need to have a lifetime without having an actual reference to attach it to. This is what is meant by \"fake field\": a field doesn't actually store any data, but it behaves as if it does. If you have a lifetime, and the type is acting like a reference, then (or ) is the recommended approach. It's hard to be more specific without knowing your exact use-case, though. In any case, the major motivation for is to avoiding having to think in terms of co*variance, and instead just think of what the intended \"storage\" of a type is. The RFC is meant to serve as a technical reference to describe the behaviour unambiguously. I definitely agree that the current docs are not as helpful as they could be.\nI see you've used lifetime as part of 's type. In my code I've used and got confusing error messages. That bit in the documentation would help a lot! (just saying is very unhelpful) BTW: the first paragraph in your comment is already clearer to me than the documentation :)\nThe example seems relevant."}
{"_id":"doc-en-rust-57d2f334ca7e6eb9a27ff090a530e28482fc6de0ed84977e0e88681660d9ec4e","title":"","text":"A previous example was referenced at the though I think rustbyexample is clearer. Note that the syntax of this example has changed recently. That didn't used to be required. If indeed what you need is something similar, you should flag it on rustbyexample for a more practical example. I was only aware of using phantom types in for use cases like unit system manipulation and such. If you can provide the gist of what other things they can be used for I can probably shoehorn it into an rustbyexample example(s) (there's IRC if I get stuck). Though I don't know when I'd get to it.\nis designed as a low-level building block to enable certain types of unsafe code to be written safely. The relationship to phantom types (as used for dimensional analysis etc.) is the name (almost-coincidence) and the fact that the language doesn't allow type parameters to be left completely unused (meaning a phantom type has to be mentioned, e.g, in , to let the code compile). Almost instances of phantom types for dimensional analysis won't care about the precise variance (unlike unsafe/low-level code) and so just need to make the compiler shut up. :)\ngreat that you've made progress!\nOkay. The distinction between them is definitely unclear then too (in the docs).\nIf it's just to make the compiler shut up, then it's a good indication that the old default was better (not needing PhantomData for most unused type parameters).\nI sympathize. PhantomData and PhantomFn are Byzantine to me as well, and I'm hitting several issues in rlibc because of them.\n, because unused parameter did absolutely nothing, even when I used a parameter with the same name a method. I don't mind having a marker, I just needed to learn how to use it.\nTo be clear, it is just the use of 'unused' type parameters for dimensional analysis/tagging where the details of the precise used aren't so important. It is extremely important for data structures building on (or otherwise not using their lifetime/type parameters directly internally) to get their uses correct, as they are actually informing the compiler of information necessary for safety. There has been a regular stream of bugs/problems discovered in types in this repo due to the old default not helping with code."}
{"_id":"doc-en-rust-d7054ea20daa5a4a6fe60f184dc3c334a5d616c1100cf85a737a4d845489a95b","title":"","text":"(I imagine that many external libs with data structures have had to insert 's since the change... meaning they were likely incorrect too.)"}
{"_id":"doc-en-rust-fe85d13756fc69b13a429420ff236490b5847972acc558da7e98dd90ef7767c1","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!\nWhere can I learn more about how this check is done? I just built stage 1 compiler with current master, and I was able to build miri with .\nI'm guessing one of the tests is failing because it now needs a . The failure should be hidden somewhere in the logs of the runner:\nshould fix tihs.\nAh, so the problem is in one of the tests.. I only checked building.\nusually, should let you run the tests, but this is currently broken by"}
{"_id":"doc-en-rust-3bee0c6575960c7d5e711d7869d77240d155eadeaccee7b79ac5e94127233fb7","title":"","text":"It shows up on and , but not on or\nThis is actually a known bug in rustdoc and/or the compiler, although I can't seem to find the issue right now... Basically it'll suffice to just tag the trait with for now."}
{"_id":"doc-en-rust-787815e479469db5d8732979a3a2fb8cdb74b973b1d640513e9e177dc7b6d152","title":"","text":"This code will fail to link because is merged into . Since global asms in LLVM can't reference symbols natively, we currently will add the mangled name to the string and pass it to LLVM. To prevent the file being optimized away, we add it to . A few issues exist: does not handle these functions specially, and therefore above is considered as internal function and have attribute attached. LLVM believes that it is allowed to merge internal functions into an exported function despite present in . I think LLVM should be allowed to this because we emit the internal linkage, and from my understanding renaming a local symbol should probably be allowed. argues otherwise and says that shouldn't touch the symbol. The symbols are , but it wouldn't show up as used in the exported symbol list, so it can still be stripped while doing LTO. We should do the following: [ ] Ensure that these functions are not emitted with internal linkage [ ] Ensrue that the functions used will be marked as used in and thus reach the linker/LTO. [ ] Ask LLVM to clarify the behaviour of combining + . cc label: +A-inline-assembly +F-asm This will block\nI think should be enough to ensure that the symbol reaches the linker even through LTO. So really the only thing to do is change the symbol visibility. This isn't ideal though since we don't need this symbol to be exported outside the current compilation unit, it's just that LLVM is unable to see the use of the symbol.\nIt could be argued that this is actually an LLVM bug since linkage is supposed to preserve the symbol name in the object file:\nI had to have to prevent from being thrown away.\nAnyway, the biggest issue is the linkage, which is wrong anyway if the global asm and the referenced symbol are not in the same CGU. Given that currently both and the linkage computation comes from the same source of truth , a potential fix should be able to address all issues simultaneously.\nThis is fixed by . The proper behavior for LLVM is still unclear, but at least fixes the immediate issue since those symbols now have external linkage. This is a separate issue, but I think the proper way to fix this is to ensure that the itself reaches the linker. The problem here is that if there are no symbols to pull in the object file containing a from an archive then that will not be linked into the final binary."}
{"_id":"doc-en-rust-c63ff82124ce80a80b12f1e20eef5d8b63f70f843493791d3f00499b65cc8293","title":"","text":"I think we can fix this by inserting a dummy symbol in the and then including that symbol in the synthetic object file from .\nIt's of a different cause, but will have the same effect. I prefer to have it tracked in the same issue (but different work items). The problem is two fold. For the normal non-LTO linking, what you described is sufficient. The major issue is LTO. Because LTO works on IR but not binary, it doesn't know if a symbol is being used in . We need to pass a list of symbols to LLVM to ensure they are kept. Currently this includes all exported and symbols, but it also needs to include all symbols referenced by .\nDo you have an example demonstrating the LTO related issue? Optimizations during LTO cannot remove symbols from yet, since as you describe the references to those symbols from the inline assembly are still opaque to it. For example, the internalize pass in LLVM comments:\nThat comment suggests that even with internal visibility, LLVM isn't supposed to delete a symbol that is used by . So perhaps the issue really is in the MergeFunctions pass which should be fixed to preserve a symbol alias if that symbol is used by .\nHere's my attempt at a fix in LLVM, but I'm not too happy about the code. It could use some review by someone more familiar with LLVM."}
{"_id":"doc-en-rust-e63342c3209c87eaa866995a2fd8dc074326f4c3a69e499f4e02cabea37f6ad2","title":"","text":"Ran into this when running a fauly tt muncher with ~100 items. We can now compete with C++ in the compiler spew area as well! :-P\nRan into this while demonstrating why you need raw pointers to do a singly-linked-queue: 66 Borrow check errors in this test."}
{"_id":"doc-en-rust-86eb39601d994e183b4132f9696838f66d6c6c6108c7944203aecb931d76f1d5","title":"","text":"The following code snippet demonstrating or-patterns crashes the nightly compiler on the Playground as of 2-2-2020. () I understand that or-patterns are incomplete feature, thus errors are expected. But I was told to anyway (cc: It's not convenient for me to test locally right now; is it possible to get a backtrace on the Playground?\nYou might want to throw this into your PR () as a test case.\nWould appreciate clarification here: I don't believe pattern binding with or-patterns within function arguments () is semantically different from a pattern consisting of only the variable name (). However, it's semantically valid code, and can be used as a contrived example to demonstrate exhaustive pattern matching. Which is how I found this ICE in the first place.\nIt's semantically equivalent, but it results in different code-paths in the compiler. I'm quite sure that will fix this though as it seems more or less like a dupe of (but different enough that a test case should maybe be ). The MIR parts of or-patterns have simply not been implemented yet, but we're pretty close."}
{"_id":"doc-en-rust-974f3a6eaeb10038ce5cceb81cc77249901dfa4e42e361c04f812096b4d1c7b2","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: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nIt doesn't seem to be related to GAT, only influenced by TAIT.\nseems like another version of\nclaim"}
{"_id":"doc-en-rust-a0777ab808493aa30d4546d94b8d6f838d0529d50b0d181e0b50b951924fd1cd","title":"","text":"Updated to via rustup. I have a and additional which specify additional rustc arguments. Now if I run The build will succeed but then fail to run qemu because Instead, there's a file named in the directory where xargo was run from. To fix this I had to change the target json file with these options: I'm afraid this could subtly break my builds elsewhere, as the linker is, in fact, GNU ld. I believe this is related to the latest -pie/-no-pie patches which somehow interfere with custom cargo linker arguments specifications (where ends up landing instead of output file name).\nSeems like is likely to be related?\nThat's my suspicion\nhmm my change shouldn't have impacted when the -pie flag was sent, only the -no-pie flag. what version were you using before?\nCould you please build with and post the output related to the link step (after the line)\ntriage: P-high Not assigning this to anyone immediately, since seems to be on it -- if you could take a shot at supplying that debug output it would be very helpful, thanks. =)\ndoes that contain the info you needed?\nIt does look weird as I don't see any standalone in the command line.\nYes, that helps. I think this is what is happening: Even though you have set in your target file to produce position-independent-executables (pass the \"-pie\" flag), the code overrides this because it sees \"-static\" on the linker's command line and decides not to generate PIE. My PR made it pass \"-no-pie\" in this case, and fall back to removing -no-pie if the link fails For some reason this seems to be confusing ld instead of causing it to generate an error Can you confirm this by manually running: (same command line without -no-pie) to see if it works correctly, and also a ? I need to look more into ld to see if -no-pie is even necessary for it, I think maybe the default pie stuff might only be applicable with the gcc front-end. If so, I think the fix would be to change the code not to generate -no-pie if linking with ld.\nnm, I think I was able to reproduce this. I don't see -no-pie documented for ld so I think that is the problem. I'll work on a fix.\nThanks, I will test this asap!\nWorks! Thank you!"}
{"_id":"doc-en-rust-28218c916560c67d0a6d904b3516e32fd0549b59493f6ce529b1086df5be86f1","title":"","text":"As noted in which tracks the diagnostic issue, the standard library previously accepted code (with differing behavior) on a number of intrinsics with \"intended to be const\" arguments. Since , though, this code is rejected at compile-time. For example, this compiles on stable but not 1.54 (nightly as of this writing). I think at minimum we need to identify the set of code that changed behaviors and document that in release notes.\ncc -- on the point about documenting this change in behavior in the release notes, would you be up for either identifying the set of intrinsics which changed behavior or documenting how to do so?\nLooking back at the crater run, we only ran it in mode, which doesn't perform monomorphization. This is the reason why this wasn't caught earlier. The full crater run for beta is currently running, so we should be able to get a clearer picture of the breakage once it is done. Documenting this is difficult: the new behavior affects all intrinsics which use const arguments. A quick grep of stdarch shows 1741 intrinsics, of which about ~150 are stable.\nThis is in 1.54, not 1.53, so the currently running beta run won't catch anything, right? It may make sense to run a crater on the PR itself, though. It is worrying that so many intrinsics are affected towards a compile-error, vs. e.g. having a warning - perhaps deny-by-default - like clippy's on the atomic Ordering params...\nrun mode=build-only end= start= name=issue-\n:okhand: Experiment created and queued. :mag: You can check out and . :informationsource: Crater is a tool to run experiments across parts of the Rust ecosystem.\nThe mechanism used to validate the immediates using const generics is: offering the validation feature: a post-monomorphization error while evaluating a forcing the evaluation of the const for the const generic parameters of a given intrinsic: e.g. the above is as and the body of the intrinsic will start with a static assertion ensuring is indeed a 4-bit value. Note that I've linked to the more common macros, but this mechanism is applied throughout including arch-specific intrinsics and validations: e.g. , or ."}
{"_id":"doc-en-rust-e19e800e21d60c7613a479b1112ad1a995890de8407b0626684dcba9f09ebf33","title":"","text":"Any intrinsic using these macros can cause an error like in the OP with an argument that doesn't pass the checks, but this set of functions should be equivalent to: all the intrinsics which have been ported to . This means this mechanism is very well centralized and could be deactivated depending on the new crater run results, however that'd mean that we would return to the current situation of, depending on the intrinsics, having assertions or crashes in LLVM instead.\nAnd the move to 'proper' const generics and the new validation are coupled because we would otherwise have undefined behavior (or be unable to codegen? -- what would happen)? Or can we decouple them?\nWe get LLVM assertion failures if invalid values reach codegen. I'm not sure if decoupling is even possible. For example, these don't work in debug builds:\nIt might be possible to do something involving specialization on const arguments... that seems rather fragile though. An alternative might be to change the LLVM IR generated by rustc, but it seems like currently rustc has no idea about the structure of these LLVM intrinsics so that probably won't be easy either. How is it then possible that the example in the OP here compiles and runs on stable?\nPreviously stdarch had massive statements to convert the value to a constant argument for the intrinsic.\n:construction: Experiment is now running :information_source: Crater is a tool to run experiments across parts of the Rust ecosystem.\n:rotatinglight: Experiment has encountered an error: command failed: exit code: 1 :hammerandwrench: If the error is fixed use the command. :sos: Can someone from the infra team check in on this? :informationsource: Crater is a tool to run experiments across parts of the Rust ecosystem.\nretry\n:hammerandwrench: Experiment queued again. :information_source: Crater is a tool to run experiments across parts of the Rust ecosystem.\n:construction: Experiment is now running :information_source: Crater is a tool to run experiments across parts of the Rust ecosystem.\n:rotatinglight: Experiment has encountered an error: command failed: exit code: 1 :hammerandwrench: If the error is fixed use the command. :sos: Can someone from the infra team check in on this? :informationsource: Crater is a tool to run experiments across parts of the Rust ecosystem."}
{"_id":"doc-en-rust-8cc21b53797abd715d91276408bd9182920c3cc6905c9ce81ce99694d75707a8","title":"","text":"edit end=masterc1ac408d93bb7adaa3a51dabab9266e82eee8 start=master# name=issue-\n:rotatinglight: Error: failed to parse the command :sos: If you have any trouble with Crater please ping ! :informationsource: Crater is a tool to run experiments across parts of the Rust ecosystem.\nname=issue- end=masterc1ac408d93bb7adaa3a51dabab9266e82eee8 start=master#\n:rotatinglight: Error: it's only possible to edit queued experiments :sos: If you have any trouble with Crater please ping ! :informationsource: Crater is a tool to run experiments across parts of the Rust ecosystem.\nretry\n:hammerandwrench: Experiment queued again. :information_source: Crater is a tool to run experiments across parts of the Rust ecosystem.\nname=issue- end=masterc1ac408d93bb7adaa3a51dabab9266e82eee8 start=master#\n:memo: Configuration of the experiment changed. :information_source: Crater is a tool to run experiments across parts of the Rust ecosystem.\n:construction: Experiment is now running :information_source: Crater is a tool to run experiments across parts of the Rust ecosystem.\n:tada: Experiment is completed! :barchart: 56 regressed and 14 fixed ( total) :newspaper: . :warning: If you notice any spurious failure ! :informationsource: Crater is a tool to run experiments across parts of the Rust ecosystem.\nAll of the new failures that weren't in the previous report seem to come from , which is already fixed.\nAnd it seems it's only 2 new crates that depend on this version of . So while post-monomorphization errors are tough errors to trigger and find consistently, the results are at least encouraging. It can also be noted that the rough \"evaluation of constant failed\" error in the OP, has since improved on nightly, to somewhat acceptable levels. <details<summaryHere's how it looks now</summary</detailsAnd could be improved still if we, for example, specialized in the handful of actually used widths."}
{"_id":"doc-en-rust-667df8d97d2e60d9b2cdc4a41cc5b79c9a7f4ad65b4013c4c87b83d9c44315de","title":"","text":"It would allow mentioning the range bounds in the error message (or we could do some of the const fn string formatting hacks here of course).\nClosing as working as intended. The error message has been improved, and a description of the potential breakage will be included in the 1.54 release notes ()."}
{"_id":"doc-en-rust-4668bc6d1c9bffda968585ed7ffaf889c5025ae8fe26b23f458ec26b75a810f2","title":"","text":"This is a common typo I make when hoisting an inconditional let binding into the let chain to merge two let-chains that could be one. The parser only needs to do look-ahead 1 and 2 to detect the case and recover. No response No response <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim"}
{"_id":"doc-en-rust-f555731ea4e464d4a3945f4923b0af1df45e1b6f6debc72c5133dab9c5118b02","title":"","text":"The following code fails to compile, because using function pointers as const generics is forbidden: However, if the function pointer is inside an array, it suddenly compiles: Is this intentional, or should it also be forbidden? <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThe first is definitely intentional. have an unstable notion of equality, in particular if they point to instances of generic functions: two entirely independent functions might have \"equal\" function pointers if they happen to compile to the same assembly code, and two identical instances of the same generic function in different crates (or even just different codegen units) might compare \"inequal\".\nThe second is a bug, good catch! I misread the issue description at first. This should not work in arrays -- I assume this would be fixed by properly moving to valtrees. Cc\nstill compiles, the issue is that function pointers are currently considered to be structural match. I intend to work on structural equality in the near (not that near) future, going to assign this to myself. claim\nSame issue with raw pointers (both and ):\nThis no longer works: Looks like the issue got fixed? We should make sure we have a test though.\nthis happens as const generics now relies on instead of simply using structural match."}
{"_id":"doc-en-rust-5b7b9164853227cf9705abea05f87305a8ae80e0d990e7c0165edcbbeb00349d","title":"","text":"Compiler crashes while compiling using Cargo. Cargo version: cargo 0.6.0-nightly ( 2015-10-17) rustc version: 1.3.0\nIt looks like this comes from the linker producing output (normal or error) that is not valid UTF-8. Fixing this in any other way than just using a lossy conversion is going to be really painful because it goes through the error logging infrastructure, which all works with s. That's certainly not ideal, because it would be best to relay other programs' messages to the user unchanged, but it's probably the only realistic way to handle this in the near future.\nJust dump the bytes as hexadecimal? I am not sure what is going on here.\nMy first thought was that the path was probably not UTF-8, but because of the way cargo invokes it that crashes rustc long before it tries to link anything, so that can't be it. I'm not sure why else the message would be non-UTF-8. (I can't reproduce the ICE on that crate (I just get a normal link error), but I can reproduce the ICE by constructing a situation where the linker prints non-UTF-8 messages.) But yeah, some kind of lossy conversion with hex escapes is probably the way to go. I'm not aware of an existing function to do that.\nActually, mapping with is probably good enough.\nfoo'ncollect2: error: ld returned 1 exit statusn` Not great, but not an ICE and probably good enough until we have a dedicated function to do this sort of thing since this should be a very rare error."}
{"_id":"doc-en-rust-55b63695a33a38f7ccfbd03dbae2b338814070458345a393e01b307046862d26","title":"","text":"We expect everyone to rebase instead of merge and we also try to have fixup commits squashed into previous related commits. I think we should document this policy, since it keeps suprising newcomers.\nI can take care of this one as it's quite a fresh experience :).\nI think we should only rebase when resolving merge conflict, or the review process has completed and reviewer request a rebasing. Otherwise I prefer adding new commits for easier reviewing.\nI agree with that this policy is sound for actually merging the PR, but it might cause confusion for reviews. I've had a PR lying around for awhile, and when there is merge conflicts the 'waiting-on-author' label gets so noone reviews it, but when I do the rebasing to get back my 'waiting-on-review' it seems as if Github sometimes loses context of previous reviews, which can be quite confusing...\nfor the record: I personally want no rebasing and just merging, I'm just stating what the policy is.\nBefore we close this issue. Could we talk a bit about ? I think we should encourage contributors close issues by keywords in PR descriptions only. Because otherwise the commit could be rebased many times, and each time it creates a reference to the want-to-close issue. Also in the referenced issue, the commit number of the new commit that could close that issue is not really informative. The PR number itself appeared in the issue is more informative and concise. In short, we create another policy for closing issue."}
{"_id":"doc-en-rust-47f681e79359d4538a29b4fe6560472bcd9c6a462701bf8783cc73cb7468c995","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at ' has escaping bound vars, so it cannot be wrapped in a dummy binder.'', 'thread 'rustc' panicked at ' has escaping bound vars, so it cannot be wrapped in a dummy binder.'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [issizedraw] computing whether is [layoutof] computing layout of -- label +F-impltraitinassoctype +F-inherentassociated_types\nah lol this regressed in cc"}
{"_id":"doc-en-rust-bc569c80357322572e626f8eaf2c3b00d729bc7540ed24da44df987bfd74c88d","title":"","text":"A while ago we merged the first backend pr to enable automatic differentiation in Rust: This was good enough to add and enable the config in and run . We would now like to improve the integration to also successfully run (to use Rust in our autodiff compiler explorer). and I looked into it for a while and while it seems like a simple linker issue, we didn't fully understood where it comes from and what's the best way to fix it. This commit has a few more changes (not yet upstreamed) that might help for understanding how enzyme is used We also have documentation here: Back to the issue. We first build Enzyme (a git submodule) and then try to link it. To copy Jed's observations: The code to add is in inside fn cargo. Note that linking works correctly when building normal crates. Also, I find it odd that this one line of code yields so many repeat arguments (as in, Is there a better way to link Enzyme? Should we prefer to elide Enzyme linking when it isn't needed or be more explicit with paths so it is always found? A potentially related linking error only happens under MacOS: Related Zulip issue: https://rust- Tracking:\nIt's not just about dist builds; this happens on any build that triggers tool builds (e.g., running would fail too). This happens because enzyme linking flags are set in the general-purpose cargo function and used in every build even when they aren't needed. changes this so that the flags are set only for the rustc build as they aren't required for other builds.\nThank you for the quick fix!"}
{"_id":"doc-en-rust-2ca9921ab5caa010237f232ab8f24b1d470bb40f055f188227f07c251c825b2d","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. --This bug popped up in CI on a project of ours. This does not reproduce on stable, but does reproduce on nightly and the latest beta (). Bisection shows that was the first build with the regression. Further bisection points to being the commit that introduced the regression. If I had to guess from the PRs in the rollup I'd say seems the most likely, since it touched the code around the error source. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nlabel: +regression-from-stable-to-beta\nReduced:\nThis assertion is indeed introduced in . The two captures have the same place but different CaptureInfo. cc\nInteresting. It's a bit hard to imagine how could have introduced this, since that just sorts a list. Fascinating! Maybe somebody from has a clue?\nActually, it's not at all hard to imagine, because introduced the following: The projections are actually the same, but the types differ in regions, which probably means that this comment is wrong:\nYeah, I just checked and the region of the match is an inferenced variable and gives an concrete ReFree instead.\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-critical\nDid some analysis: We cannot just replace the with . This will create two mutable references in edition 2021 and fail borrowck. Pre-2018 the places do get merged later so the issue isn't exposed. None of the upvar code makes use of the region info, and writeback will erase it anyway. So I think the fix should just be have the region erased when inserting/looking up from capture_information. I can submit a PR if you haven't started\nI just started looking at it but if you have a solution, go for it!"}
{"_id":"doc-en-rust-e069b79606f16c6d2ac39c8a13fb97e9872ffe26fc977e371d85653ad341ce4b","title":"","text":"Happy to review your PR\nI'm not sure about region code that much but regionchk uses the regions created: I think at one point mentioned getting rid of the region field entirely in UpvarBorrow, but since it wasn't required the discussion didn't proceed. Also it's more like this is a bug of the capture analysis than the sorting. We should never have two same places going into min capture in the list.\nI was thinking about erasing the region from s (i.e. the key of captureinformation). But it turns out that's used later to create upvar tuple... So I switched captureinformation from HashMap to a linear vec looked up with custom eq fn instead."}
{"_id":"doc-en-rust-18c29b3d63e8c543f7fd8579792e7bba7af6874318c9d955f0f1892b0cd52517","title":"","text":"This effectively means you can't compile for these targets.\nThis may have been caused by the i128 PR ( ). No LLVM assertion is raised if I compile with , which removes the i128 stuff. We could try to fix this or we could cfg away the i128 stuff for the nvptx targets in the meantine. The LLVM assertions render the NVPTX backend unusable in the nightlies. cc Have you seen any LLVM assertion like the ones above while working on implementing i128? cc cfg?\nno, I can't remember seeing such an assertion. It seems to be in PTX related code. but its very likely that i128 broke some of the non tier1 platforms. You can only tell whether they break once they actually do :/ Can you try to generate a minimum reproducible example? Then we might know more...\nSeems like the msp430 target broke too: with Using works fine. cc\nExamples\nmsp430 EABI doesn't specify how to return 128 bit values, and LLVM does not support them on msp430, so I don't see an easy fix for this.\nThese are tier 3 platforms, so basically anything goes IMO in terms of language guarantees. If they don't support i128 at a fundamental level then it seems like if we want them to compile we'll have to cfg out support.\nI'm trying to understand this better: If the ABI does not specify how 128-bit values are passed/returned, does that mean that the architecture doesn't support 128-bit values at the fundamental level?Do all the ABIs of the all the other platform 2 targets (x86, ARM, MIPS, PowerPC, SystemZ) specify how 128-bit values are returned?(What about wasm and Do those even have an ABI? How does the 128-bit stuff even works there?) I'm wondering if we should: Add a field to target specifications. For targets that don't support i128 at the fundamental level.Or, maybe add Cargo feature to to cfg away the i128 stuff.Or unilateraly cfg away i128 in core for nvptx and msp430. I personally don't like either option. To me this seems like a limitation in what LLVM can do today but that can be fixed in the future."}
{"_id":"doc-en-rust-9f60f9e091baaf1c242567d672730d63fc856ddd74df590cccd881cb752afd39","title":"","text":"Also, if we had pure MIR rlibs this wouldn't be a problem at all because the i128 stuff would never be passed to LLVM if it wasn't being used by the final application. To sum it up, I'm not sure what to do here ...\nRight now on MSP430 values from the functions are returned using 4 16bit registers r12-r15. So in total you can return only 64 bits of data. There is an exception though, for returning large structs, the data is placed on the stack and reference is placed in the registers. So I guess it will be possible to bodge some hack that will treat i128 like a struct, but I don't know if anyone tried to implement 128 bit values on 16bit cpu, so it will be a new territory and potentially a lot of work for a feature that may not be useful at all on a small MCU.\nyeah, but if LLVM can generate code for a function that returns then it should be able to use the same trick to return an . It's just that noboby has taught it how to do that. (i128 ops are totally different though but at least LLVM should emit intrinsics instead of raising assertions) How about on 8-bit AVR?\nAFAIK, if Rust code calls Rust code, the ABI is totally irrelevant. We can do whatever we want. However, it starts getting a problem once we start talking to non Rust places, e.g. for FFI, or when LLVM emits a call to i128 intrinsics. For FFI we might want to end up forbidding fn's and structs that have i128 for targets where i128 is not specified by the convention or buggy in LLVM. With intrinsics, there has been major pain on Windows with because LLVM assumed a different ABI than what Rust provided with . It was \"fixed\" by introducing the \"unadjusted\" ABI, and it might work for nvptx64/msp430 as well, but it can just as well still cause an assertion failure. Real need for is only for platforms that want to cryptographic libraries, or maybe even std, as those two places might want to use . The higher stages of the compiler itself require i128 support as well, so if your platform wants to be a host platform for rustc, you'll need to support i128."}
{"_id":"doc-en-rust-9023216777c595fb87db7d468306d524e44b25dd772b4954c7321d668dfdd43a","title":"","text":"I'm okay with any of the three options (flag in , feature for , only setting it for those two platforms) for these platforms.\nNo. No. Namely the x64 windows ABI is kinda fuzzy about how i128 values are handled so carefully reading it we arrived at a conclusion that they ought to be handled the same way as regular 16-byte structs on 64 bit window platforms. A target cannot not support i128 at a fundamental level the same way a target cannot not support writing turing complete software. IMO what we should do here is to fudge the ABIs somewhat to take and return arguments via pointers (or the same way would be handled) on these targets. C ABI will be more complex; as already said there will always be at least one user of the C ABI with i128 arguments and stuff – LLVM with their intrinsics. The question here is how does LLVM lower to the intrinsics on these targets. If the backend does not lower and asserts for whatever reason, the targets have what’s essentially a broken backend implementation. Which seems to be broken for at least NVPTX () in exactly the place where I’d expect it to be broken if it was broken: That being said, since the C compilers do not support i128 for those targets, the actual interoperation does not matter whatsoever. All that’s really needs to be fixed is LLVM’s lowering of instructions to intrinsics using whatever ABI that works, even if its passing in arguments and taking return value via pointers. I, myself, am very strongly against splitting the language feature sets depending on the target.\nHow do we break the stalemate? If we submitted changes upstream for each of the smaller targets w/o support for i128 (providing indirection like large structs) it seems like it would meet resistance. As says, it's likely not considered useful since there's many targets without any native registers or support for such large values. But we also also have reluctance to limit this type to only appropriate targets. Does the \"vision for 2017 cycle\" provide any guidance? Does \"provide a more seamless FFI story\" help push us in one direction or the other?\nregardless whether useful or not, we do need to support i128 on all targets, otherwise people will start using libraries that provide it across platforms."}
{"_id":"doc-en-rust-e257847275cfff1d0ae9adea1a5795d6237cb5f020c2af6bf4c187b019de696f","title":"","text":"Even if it needs to be \"virtualized\" in some way, and not wholly put into registers. In the worst case we'd have to provide some translation before passing things to LLVM, but it will affect things like alignment and generally looks like an ugly workaround. About FFI, I guess we can't really provide any FFI for i128 on targets where there is no C support for it, as generally the calling conventions only specify things that are part of C.\nNone of the targets Rust supports have native support for 128-bit integers, other than the fact that some can implement unchecked division and multiplication involving 128-bit integer operand with a single insn. Why? All that needs to be done here is to have the backends fixed. LLVM is supposed to be agnostic over bitwidth of integer, however useful or not somebody on the internet perceives such functionality to be. In other words, its a backend bug. So, its probably pretty clear that all it takes is to write a patch to fix bugs in these backends wrt operations on large values. I have no knowledge of these targets, am not familiar with the backends and haven’t the hardware to test any fixes on, so these patches will have to be written by somebody else. Late answer, but I’ve noticed this only now. This observation is wrong in multiple places. Firstly, (a.k.a. returning via pointer) is not a hack. Neither is it an exception. That’s what pretty much every single ABI¹ out there does for values that do not fit into register(s). It is most likely true that MSP430 ABI does not specify what to do with PODs this large, so it falls on us to pick whatever. ¹: For a less obscure example, x64 ABI used by code targetting Windows mandates to be used for any non-vector values over 64 bit in size, even though they could be fit it into registers. SysV ABI starts returning stuff via after some size threshold as well.\nThe MSP430 ABI specifies that aggregates larger than 32 bits are passed and returned via pointer. The backend just doesn't implement sret correctly yet (and in fact is implemented targeting an old and outdated ABI in any case). I'm working on fixing this in LLVM."}
{"_id":"doc-en-rust-b2cbc757d26316923461eb433588f927fa1428c6a9986154b7a630f750322456","title":"","text":"I'd bet that similar problems explain the NVPTX problems but I know nothing about that platform so I can't say that for sure.\nI also agree that fixing backend is the right thing to do. I just think that it is not that easy as you say it is. MSP430 is the only 16bit architecture in LLVM, and this creates some trouble by itself. Good to know that someone is working on this.\ndoes that LLVM patch really fix NVPTX as well?\nNo, it doesn't. this should be reopened for NVPTX.\nBTW, thanks to for fixing this in LLVM upstream.\nTriage: MSP430 has been fixed. No change in the NVPTX backend.\nWhat needs to be done to get NVPTX working again?\nYou can see the patch I did for the MSP430 above - if it's the same problem you basically just have to add sret (structure return) support to the LLVM backend. I don't know anything about NVPTX but I'd bet it's pretty much the same procedure as what I did for the MSP.\nNote that you can use the NVPTX backend today with the nightly compiler if you use a fork of the libcore crate that doesn't include 128 bit integers. Instructions .\nI have some progress on the issue. First, I tried a hacky workaround with replacing with in arguments and return values with a custom FunctionPass. Can be transformed to: And compiled to PTX with vanilla LLVM (): Then, I made less hacky workaround patching LLVM NVPTX backend so it became possible to compile the code with without additional passes. Is compiled with patched to pretty much valid and working PTX assembly ;) But another related problems appears. When instead of: I write: I receive an error: And similar error when I try to compile : Does anybody have any suggestions about the problems? Looks like PTX doesn't have an instructions for the functions, and LLVM can't expand them.\nLooks like the expansion from i128 to i64 is going OK but the i64 sdiv/mulo instructions aren't properly implemented. Not sure why that might be... it kind of looks like it's trying to assign the address of a library call and that's not working. Possibly the way you implemented the i128 expansion prevented a subsequent i64 expansion from running but I can't tell without seeing the code."}
{"_id":"doc-en-rust-8871b1facc0ac19219f83635d4cb257fc1a13235057cd94017a7ffc0ae5d3b7d","title":"","text":"Run llc with -print-before-all and/or -print-machineinstrs to see where things diverge from what you expect. Look up in your platform ABI what the right action to take for 64-bit divides actually is. Post a link to your changes and someone may be able to take a look at them and see the problem.\nTraditionally, in LLVM, is implemented by the library. However, its disabled on most platforms. Not sure why, but is written in C so they probably only can support i128 on platforms where they also provide C support, and clang's C support for i128 is right now very limited. Rust however the function, inside the crate (that is a wrapper for compiler-rt). There are good chances it works already!\nIt has pretty expected output before and after each pass. I think more interesting would be output with , but I don't really understand it. of the next commands: I tried to make changes over LLVM as minimal as possible: . I'm quite confused about and . Should they be compiled for target or host? If we can build at least for NVPTX, then can we just link against it? It still require some more changes for LLVM to be able to threat libcalls as normal calls. But then, all we would need is to link against . This blocked by but might be solved with my experimental .\nFor the target. At least its that way on other platforms. What is LLVM doing on 32 bit NVPTX when it encounters a 64 bit operation? On normal targets, this is one of the places compiler-rt gets used. Or idk, to cast a float to an int and back.\nby the way, I didn't congratulate you yet for your progress. Really great work, loving it!\nI'd like to see this move forward, so I'll summarize the above. Please correct me if I'm wrong: This issue was fixed for the MSP430 backend by submitting a patch to LLVM. worked on a patch to do the same for NVPTX, but it was not submitted to LLVM. I imagine that since that was a year ago, the patch will need some work to bring it up to date. Is this problem still happening with more recent builds? Perhaps it's been fixed by upstream in the meantime."}
{"_id":"doc-en-rust-c1b55cf71ec84cc4cabbf6814d60b0c4846774ce0eb280ded78f0ecbbc3688f5","title":"","text":"If it is still a problem, what would have to be done to fix it?\nWell, my patch related to landed in LLVM about year ago. Now we can compile simple examples without any problems: with which produces the PTX assembly: And as for me, the issue can be closed. I was able to compile a kernel from  with latest nightly. So the hack with custom is obsolete now."}
{"_id":"doc-en-rust-2787a6c71d4e0e29dd036df2d00b6192dd8a246efe5d986679796d962dbb5498","title":"","text":"LLVM's MergeFunctions introduces aliases which can trigger a bug in macOS's linker when compiling with ThinLTO: For this reason Firefox has to be built with a patched version of when compiling with xLTO. Since the bug in question is pretty nasty (the above example shows a program just returning a different value with no indication that anything is wrong), we should probably try to not trigger it. Right now, however, it seems that one cannot even turn the MergeFunctions pass off in stable Rust. (I wonder if the pass should even be disabled by default on macOS?) cc & (this seems related to )\nIs it a mergefunc bug or a ThinLTO bug? Can it be triggered without ThinLTO? If not, I would rather not blindly disable it on macOS, at least not when ThinLTO isn't enabled.\nIt's not a bug in mergefunc. It might not even be a bug in ThinLTO. It's just that mergefunc is the only thing in that generates symbol aliases in LLVM IR, and these are what can lead to \"miscompilations\" when using the macOS linker.\nHas the ld64 bug been reported somewhere?\nWe could use to prevent the pass from emitting aliases on macOS, AFAIK.\nThis is already supported via either or in the target spec.\nDo you mean that the test case also fails with enabled, or that we already have a knob to disable them?\nAnswering my own question, we already have a knob for that.\nWhich was because .\nAs and point to there is the unstable option which I've only tested on nightly. I guess there could be a stabilized option, but maybe what you really want to do is to patch the x8664 macos target definition (I believe this is the correct one: ).\nYes, I've been told that it has been reported to Apple. On nightly, one can already control the mergefunc pass. On stable, however, one is stuck with the default behavior. That's what this issue is mostly about.\njust want to double-check my understanding: I would have thought one could use the options and to override the set of passes, even on the stable channel. Am I incorrect about this? (If I am correct, I nonetheless will admit that this is an ugly (and very fragile) method to opt out of the MergeFunctions pass)\nI think that is correct, yes."}
{"_id":"doc-en-rust-0f6cd2cd2322116fcac9ca8e1a8441068fcad4384e0d52f557f461f4235bb268","title":"","text":"It would be rather hard, however, to re-create the set of passes meaningfully, I suspect. Even the compiler delegates this to methods within LLVM, iirc.\nI think using might work on stable.\nSo did that help,\nUnfortunately not. Specifying this gives me:"}
{"_id":"doc-en-rust-bf30b8edc1f364ae67d3fdba2c0a9a2803e910cf066ca54c581bed7df1c8f9ad","title":"","text":"Test case: With rustc 1.20.0-nightly ( 2017-07-06), output when compiling with : correctly stops the dead code / unused type alias warning from being shown, but the trait bounds not enforced warning is shown anyway. Per and , this might be on purpose. I think this is the wrong decision. The point of is to allow Cargo to inhibit warnings in external dependencies. When building Servo it is not useful to spam the console with many warnings, future-proofing or not, about code that Servo has not direct control over. CC\nNominating for discussion. Not sure if compiler team or lang team is best, though, so tagging both...\nFrom the lang team's point of view: definitely a bug.\nCouple of bugs here: First off, we should not be ignoring the bounds in types. And sometimes they are needed. I'd like to fix this by not ignoring them, but I worry about the backcompat issues. Unknown risk there. Second, if we must warn, we should be emitting a regular lint that can be silenced. Plausibly, we should just remove the warning (eliminating the immediate problem), and prioritize trying to do a proper fix here.\nSomewhat related to not ignoring bounds (but in the other direction): .\nAfter some discussion in compiler team, decided to move this to a \"future compatibility\" lint, one that we will hopefully make more precise over time. Right now the check is not very good. At least this means you won't have to see it. We need some mentoring instructions though!\nSome tips here:\ntriage: P-medium\nI've hit this recently. It seems like it is possible to write code that requires exactly this bound. So it is quite bad that we cannot suppress this warning. Example code:\nAgreed, this is poor. There just hasn't been a lot of energy to try and improve the situation.\nFixed in , probably by We should add a regression test for this particular case before we close this issue however, since I don't think the test in the PR detects a regression for the problem described in this issue. The problem in this issue is output on stderr, not that compilation fails ( exit code is 0 both with and without the fix in the PR). label E-needs-test"}
{"_id":"doc-en-rust-874306207f9a879e4f39021370b30a8d98692ef46b5f3fc2924e3483bb84b43f","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\nI suspect this is related to cc\ntests/ui/suggestions/unnamable-\nVery likely. I'll take a look soon.\nFor the record: it was that caused this."}
{"_id":"doc-en-rust-044a977d6ee5e37bd83efffc4be02a384d88ffabbdc32d99ddf528fd37df2cca","title":"","text":"Rust PR: This feature adds the following methods to : -\nAnything in particular holding up the stabilization here? The implementation is trivial and docs lgtm.\nI would like to add methods that return an exact , but that can wait.\nThese methods are a little odd, but seem reasonable to me following the example given:\nGiven how straightforward these methods are, I don't think there's any problem stabilising them?\nThey're straightforward in implementation, but conceptually tricky at a glance. I think the docs will need some fleshing out before stabilizing but I don't have any other concerns if somebody wants to write a PR!\nThis needs more testing with various interesting values that could produce interesting floating point numbers, and should not be stabilized without such.\ntests were in this PR"}
{"_id":"doc-en-rust-58bf6573f1d681e85db6ff57e65208710918ad2914a33c9f21c119937195934d","title":"","text":"It should work a bit like IDE's feature that finds everything that implements a given interface.\nThis should be a fairly small change (the most annoying part has already been done) so i'll open this up as a mentored issue. The bit that writes out the \"Implementors\" section is in . This is where the known implementors for a given trait are pulled out of the global context and listed out onto the rendered page. The bit that's responsible for creating links is , implemented on a local type. This kind of Item is easily made from the kind of Item that's otherwise worked on in , but there's a catch: The entries in the Implementors list aren't s. They're s, which are only a subset of the things you get on an Item. This is the \"most annoying part\" i mentioned earlier. Fortunately, i ran into this when creating the \"Implementations on Foreign Types\" section, so if you scroll up a little in , you can see so i could render the full impl block for them. The task for anyone who wants to take this on is to pull that up a little so that it's used for all the implementors, not just the foreign ones. With a in hand, combine it with the Context to create a and call to generate the link. ( This also helpfully includes the extra HTML bits that will flush the link to the right edge, which is really the final step.) And... that's it! The link should probably go between the and the where clause underneath it, so that it's aligned with the impl line and not the where clause. You may need to also close/open the that's wrapping the whole line to make sure the link itself isn't monospace. If you have any questions, let me know! Either comment here, or hop onto IRC in , or the impl period Gitter under ."}
{"_id":"doc-en-rust-c175a8052f071465a6940cc82e09791a9969242ec0762a03d622b26268d4e5ea","title":"","text":"On nightly (and beta I believe) the compiler will currently fail when cross compiling from x86_64 to x86 (after ensuring the standard library is in the right location) with the message: I believe this is a regression from and , which were backported, so I believe this is a stable regression. That being said I doubt anyone other than Cargo CI is doing this, so it may not be that big. I also believe that is working on a patch, but this should help track this issue.\nI have been doing this with ring and ring-based projects for many months."}
{"_id":"doc-en-rust-0d66daaa0bff00bac72eeed0cf105ff52674eddc0c0d81b7567f2553268afa0d","title":"","text":"This issue is a proposal for the deprecation of error code . I opened a PR () as part of an effort to add long error explanations for error codes that didn't have one (). I chose and for my erroneous code example, I used the example from . I quickly realized, through running the example and other code that would also raise and through the CI failure message, that was not being raised. I went back to consult the issue I received the original code example from and noticed comments about not occurring anymore with . The issue was eventually labeled with . But, looking at the current contents of the file, can still be emitted even while it isn't: also doesn't have any UI tests as it is part of the error codes in . Since , is no longer actually emitted (although it is in code that it could) thanks to , I believe it should be deprecated. I would be happy to help deprecate the error code, if it is decided that it should happen. I would just need to know the proper steps to take to deprecate an error code. If there are reasons for why it is still an error code, I would love to be enlightened. claim <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nIf is not emitted anymore then it can be removed immediately. A crater run can also be done to ensure that this is the case. I'm also happy to do this if you want.\nSure, that sounds good.\nSorry just for clarification, do you want me to do the PR or you?"}
{"_id":"doc-en-rust-4b896e75ea201d5026a72d90704af60b8d8f16ff87fb6c41e963080cb6fd89bb","title":"","text":"The following program compiles, and prints :\nAs pointed out by on discord , this also works on stable:\nRegression introduced in 1.40.0, specifically this line:\nI have a fix in"}
{"_id":"doc-en-rust-32273abb043c6654aef23523563421842d54754f8b9fce5abf25a92a8e46d2f3","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: Compiling with , after the emsdk is activated and emcc works, to compile properly Instead, this happened: Prints this error: I've tried adding to no avail <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details\nruns successfully\nAlso is broken on ubuntu with the same error message (at least windows subsystem for linux)\nrustc 1.53.0-nightly ( 2021-04-24) emcc (Emscripten gcc/clang-like replacement + linker emulating GNU ld) 2.0.12 () Here's some info I gathered: Rust tries to . I think Rust is assuming that this symbol comes from emscripten. emscripten has a : libc++abi.a: emscripten exceptions: this is what rustc is trying to use; libc++abi-noexcept.a: no exceptions: does not compile libc++abi-except.a: wasm exceptions: experimental; in emscripten's repo shows that was never compiled into libc++abi.a by This commit looks suspicious: Prior to emscripten SDK version 2.0.10, I think has been and never did anything. Rust probably shouldn't be calling a stubbed function. seems untested if you ask me because I don't know how it could ever have worked. I successfully compiled hello world with emscripten SDK version 2.0.9. That version still has the stub.\nlabel I-prioritize T-compiler O-wasm\nthanks for the analysis. Assigning priority as discussed in the of the Prioritization Working Group. Let's find someone who can have a look at this. label -I-prioritize +P-high +I-nominated\nI recall with the LLVM 11 upgrade, the compat notes mentioned which version of Emscripten to use when compiling with the target."}
{"_id":"doc-en-rust-38683d685d5a2a1efc8f9b0db358ce891cf6d930c0ffdef3ecd1788cfc2a9226","title":"","text":"Once this bug is resolved, can we add a similar note for the releases that upgrade Rust to LLVM 12?\nAs mentioned the panic=unwind strategy is broken on wasm32-unknown-emscripten. I recommend to switch default to panic=abort. Note that also rust std lib has to be rebuilt with panic=abort to fix the undefined symbol errors. Testing on my side showed that the problem could be fixed by changing TargetOptions on line 38 to \"panicstrategy: PanicStrategy::Abort,\" in file. Unfortunatelly I do not have experience in preparing pull request and have no capacity to get into it now.\nThis issue can be solved by setting the env var which will override any flags passed to emcc. See this comment - Passing these flags using the won't work, as they are not passed to the linker. I received this error in two places, one for symbol and one for , hence the flag.\nReported this on Emscripten:"}
{"_id":"doc-en-rust-5403be4736dcdebcacc161ad98cf88b87d02ef27a07e54c42506e3e30d54d00e","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\nprobably Regression in searched nightlies: from nightly-2023-02-15 to nightly-2023-03-16 regressed nightly: nightly-2023-02-20 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 actually\nOr at least, the logic broke because of , so the ICE message probably changed in that PR from some other message, to this one in the title.\nlabel +S-bug-has-mcve"}
{"_id":"doc-en-rust-3b97c0446b049871b66af0aacf8d6f5b25ea52a83d1a0d1f1d7d3cfaa0672f04","title":"","text":"Some people were of the opinion that this shouldn't work, but it currently does. : cc\ncc\nit's just super scary. EDIT: it should not and does not work. If we allowed this, various surprising things can happen, especially around implicit promotion. If you want to store pointers and integers, you can use a raw pointer.\nFor my own education, can you elaborate on why function pointers are ok? I'd thought that the runtime addresses of things -- including functions -- shouldn't be accessible at const-time since we don't know where they'll live at runtime. Could I make a const array that usize long?\nWhen compiling to LLVM, the real function handle or pointer address is obtained. If you try doing anything weird with pointers at compile time, you will quickly notice that you are not at runtime. For example, you cannot divide such a usize by anything. You can add or subtract integers, because that's just pointer offsetting, but you can't inspect the address in any way. This also means that no, you cannot use this usize for array lengths or enum discriminants. This is due to the fact that miri pointers are not just addresses, but abstract pointers that are in a separate layer from the bytes of normal memory like the one of integers.\nThanks for the explanation. I guess that means that such a couldn't be passed to a const generic either?\nThe thing is const generics don't know where the usize comes from, so they could try to do something with it that is not allowed if it is just a pointer address. Until monomorphization we can't know if there is an issue. Note that converting a pointer to an usize and back just to be able to put it in const, statics, or use it with const generics, is a real pain. We would be better off in this case with an type, such that I can write and avoid the conversion to usize. For const generics, C++ accepts function pointers at the type level and that works just fine with clang, so I expect to work fine as well.\nHow would work? is disallowed but and work? that seems very weird and special cased (especially for fn types that involve higher rank lifetimes, as in my example) or is ~= ?"}
{"_id":"doc-en-rust-186661af979691142d781fb362764a5d3fbb269992b5769a294bf99eec2f8644","title":"","text":"then is a double indirection and to use it you need to worry about managing the memory it points to (which contains the )\nI haven't thought this through beyond having used the atomic pointers in the C++ standard library: One way to implement this could be where we provide blanket impls for , , , , , , , ... or use some compiler magic to achieve a similar effect...\nThis is a bit offtopic, but regarding , mentioned at least once the possibility of introducing some new type, to make sugar for . I guess it can't entirely be \"sugar\", because of existing impls, but at least both could work the same.\nHehe, this is cute. :) And I agree it is working as intended. (Nice that the translation to LLVM actually gets this right, should there be a testcase to make sure it stays that way? :D )\nSo... other than testing this, all we need is a PR that adds -casts in constants under a feature gate (and makes those casts unsafe in constants and )\nI've opened to brainstorm how to either add an type or retrofit to support items.\nThese kind of operations are now unsafe in contexts (impl PR: )\nSo do we have a test that you cannot use such usize as array length? :D\nhmm... apparently not... Test-instructions: (via the feature gate) to turn various kinds of references and function pointers into these expressions in array length, repeat lengths and enum discriminant initializers (e.g. ) Note: Do not use items, everything needs to be inline in the use site to be properly tested\nthis is no longer allowed by any means:\nYes that is intended. This issue is for adding a regression test testing what happens when you use a pointer casted to a usize in an array length."}
{"_id":"doc-en-rust-3a18f934546070b2ca40f472739a943382c8f3b64d81650a47d307777fd60c77","title":"","text":"The following panics: The following works: Apologies in advance if this is intended behavior.\nI have found that it also works when using:\nThis will be fixed by"}
{"_id":"doc-en-rust-f3bfa6d834c46600d3869cbdfdac1ba23ee221d3907dbcfa430172612f8bf8af","title":"","text":"<!-- ICE: Rustc '' 'thread 'rustc' panicked at 'assertion failed'', 'thread 'rustc' panicked at 'assertion failed'' File: --auto-reduced (treereduce-rust): &lt;details&lt;summary&lt;strongoriginal code&lt;/strong&lt;/summary&lt;poriginal: </p</detailsVersion information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details\nRegression in nightly-2022-02-02 found 9 bors merge commits in the specified range commit[0] 2022-01-31: Auto merge of - spastorino:fix-perf-overlap-mode2, r=nikomatsakis commit[1] 2022-01-31: Auto merge of - tmiasko:is-self-recursive, r=ecstatic-morse commit[2] 2022-02-01: Auto merge of - WaffleLapkin:rustcmustimplementoneofchecktarget, r=nagisa commit[3] 2022-02-01: Auto merge of - eddyb:diagbld-scalar-pair, r=jackh726 commit[4] 2022-02-01: Auto merge of - ehuss:rollup-9ecozo9, r=ehuss commit[5] 2022-02-01: Auto merge of - thomcc:chunky-splitz-says-no-checking, r=the8472 commit[6] 2022-02-01: Auto merge of - eholk:disable-drop-range-analysis, r=pnkfelix commit[7] 2022-02-01: Auto merge of - matthiaskrgr:rollup-f7dkn3p, r=matthiaskrgr commit[8] 2022-02-01: Auto merge of - yaahc:Termination-abstraction, r=Mark-Simulacrum ERROR: no CI builds available between and within last 167 days\nActually reduced\nMight have been caused by\nAh yes, the assert was there ping :)"}
{"_id":"doc-en-rust-5220d5a8d8d86613c4381ae5bdff14152e89290d442600e3c2f39476da0e5bee","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. --Explicitly giving lifetimes to with and doing the same on does not fix the ICE either. Version\nlabel +S-bug-has-mcve\nTriage: Fixed on the latest nightly, labels: +E-needs-test"}
{"_id":"doc-en-rust-c0a929f18bcfc09b4140d3b23a5400af201e9bb77c0ec58f078f31dbf3455980","title":"","text":"and all interfaces directly with the file-system should probably use rather than trying to coerce to handle these cases. (Similar issue to .)\nnominating feature-complete\nAccepted for backwards-compatible\nMy last referenced commit is a month old, but I'm still working on this issue (currently finishing up the support for Windows paths).\nThe issues here of dealing with filesystems that are not utf8 seem related to , at least tangentially."}
{"_id":"doc-en-rust-56861bf654c3538806d7378297409a08d9df48c6a42df7b0eb2c277d290a5fb4","title":"","text":"was re-stabilized in 1.53 after being backed out of 1.51 due to breakage, primarily in the lexical-core crate. This breakage has not been fixed, as far as I can tell, in a vast majority of crates: we're still seeing ~1300 regressions, majority of which are lexical-core in the . There was no discussion on the re-stabilization PR as to whether this level of breakage is acceptable. Comments on the original breakage issue suggest that 0.7.5 was published with a fix, but older versions (0.4, 0.5, 0.6) did not receive similar treatment. The majority of the breakage is in crates locked at 0.7.4; the other versions do share ~400 different crates amongst them, so I think it'd be good to try and help get those series patches as well.\ncc Even with 0.7.5 out, it does look like it'll be some time before crates actually update lockfiles (if ever). We don't have a firm policy on whether cargo update being sufficient is \"enough\" that breakage is OK -- it's a new decision each time pretty much -- but this level of breakage is pretty bad. I guess there may not be much we can do -- IIRC a prelude trait for example adding BITS wouldn't help here, right? Those still introduce conflicts IIRC.\nThere’s no way around the symbol collision. I think it’s important that stabilize and I’d like us to get out of the way on that. I can take the list of broken crates and start walking it. I can also work on a backport on the older minor series; the reason I did not do so last time is that I was unfamiliar with ’s dependents and didn’t know whether the older series were still in use. What is the most complete course of action we can take to clear for stabilization? Should I yank the conflicting versions in each minor series? Alternatively, would it make sense, and is it even possible, to stabilize only in ?\nI wouldn't worry about filing pull requests with 1300+ crates bumping lock files (in part because those are unlikely to get merged quickly). I do think getting patch releases out for each series would already be a significant step forward."}
{"_id":"doc-en-rust-853e13bc77576d7947d5a0dc1bae646536762bf976cbd7b83c8de29bfacbee31","title":"","text":"I think yanking is likely not the right step to take at this time. In terms of stabilizing only with - no, that's not really possible. In theory we could stabilize with a different name to avoid all the breakage, but I doubt there's a great name...\nThe constant would have to be available everywhere, and stable everywhere, but one could think about adding a syntactic hack to interpret the syntax differently depending on the edition, similarly to how it was done for . That would have the desired effect of avoiding breakage on editions 2018 and before, but I'm not sure it's a good idea to double down on adding such hacks.\nAttaching it to an edition would not only require compiler changes, but also a lint, a suggestion for rustfix, documentation, etc.\nIndeed. Such a policy would be useful. If the decision is that that's fine, we might want to make crater update the lock files when something fails before it considers a crate broken. As another data point: also ignores the lock files and picks the latest matching version of everything.\nI assumed the edition route was an infeasible idea but hey might as well get a “no” in writing. I’ll start cutting fixes for the minor series listed in the regression report this weekend.\nThank you! Let me know if I can help.\nI'm wondering if we should have a in (just like ) that will make Rustc consider everything that was stabilized in a later version as still unstable. could add it to the uploaded crate if it's not explicitly set, and it makes it easier for crates to track an explicit MSRV.\ndid you get a chance to release new patch releases on each of the channels to avoid this breakage for the lexical crates, at least? I believe that was the plan but I haven't seen updates on this issue at least :)\nHi; I am so sorry for the radio silence; I have had quite the month since then. Fortunately, Alex Huszagh already did the patch-release issuance back in April. versions , , , and all appear to have the necessary disambiguation in place. These versions also do not appear in the regression report from Bors. I've also run on each of these releases with and passed, so these tips ought to be correct when the constants stabilize. I hope day-before isn't too late and I apologize again for the delay."}
{"_id":"doc-en-rust-b454ea6237523ff5cd281da779ee4af261cbb366d01a5ff0fc804512d12ccc07","title":"","text":"If you're comfortable with a \"run to un-break your project\", then is ready.\nNo worries. We are planning to move ahead with a compat note indicating cargo update.\nJust an FYI: this was fixed ~2 months ago, with , , and . It means that any branch used in the wild should be able to be updated to a compatible version now."}
{"_id":"doc-en-rust-79e2c770627c8cad0f02499a2dfc372d359970372318fd2b2f5fbacb68de3e2f","title":"","text":"I have this crate layout: src/ parent/ where is an empty file and is: This compiles successfully and we end up with a module at backed by the file But if goes anywhere near a proc macro, it no longer works. where is this macro: The error is: so it is looking for a file corresponding to as though the were not contained inside of . I hit this while working on The same problem does not occur if is defined as a macro_rules macro. Mentioning who may know what is going wrong or whether there is a simple rustc fix.\nI never audited the module search code and don't know how it fits into the larger macro story. Even without macros it's , so I'd expect issues in macros as well. I'll investigate.\nStill the same behavior as of rustc 1.40.0-nightly ( 2019-10-01).\nIt's still in my queue, just not with a high enough priority :(\nThis was fixed by , I'll add a test."}
{"_id":"doc-en-rust-73b67c266ffea610d4a46c1dee1f7954b0576e172c2313b3d9819a76387d092d","title":"","text":"Unicode is released on a yearly basis, so we update the data files we used accordingly after each Unicode release in the Rust project. (Keep in mind that new dependencies might be over time.) 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. Goal: Unicode 15.0 (year 2022) [x] Updating : [x] Verify whether each crate is Unicode version dependent and add support for the new Unicode version in compiler dependency libraries [x] Bump dependencies and ensure updated version is used in [x] [x] [x] (Decide whether it's a valid identifier) Current: 0.2.2 (Unicode 13) Goal: 0.2.4 (Unicode 15) [x] (Preprocess identifiers for equality) Current: 0.1.13 (Unicode 9) Goal: 0.1.22 (Unicode 15) [x] (Decide whether lints against unwanted usages should be triggered) Current: 0.0.5 (Unicode 13) Goal: 0.1.0 (Unicode 15) [x] (Used by for script detection) Current: 0.5.3 (Unicode 13) Goal: 0.5.5 (Unicode 15) [x] (used by , and many others) Current: 0.1.8 (Unicode 13) Goal: 0.1.10 (Unicode 15) [x] (used by ) Current: 0.1.0 (Unicode 15) Goal: 0.1.0 (Unicode 15) [x] Removed: [x] Removed: [x] Removed: [x] Removed: [x] Removed:[x] Verify whether each crate is Unicode version dependent and advocate support for the new Unicode version in dependency libraries [x] Bump dependencies and ensure updated version is used in [x] [x] [x] [x] (used by then then [, , , , , , , ]) Previously: 0.3.4 (Unicode 10) Goal: =0.3."}
{"_id":"doc-en-rust-13a75cc457f26e441b6f783fe1e7b5d68d954331a49f5a47277709d836bc10c2","title":"","text":"10 (Unicode 15) [x] (used by ) Previously: 1.9.0 (Unicode 14) Goal: =1.10.0 (Unicode 15) [x] (used by ) Mentioned above in compiler diagnostics section [x] Removed: [x] (used by , then [, , ]) Current: 2.6.0 (Unclear, No release in 3 years) Goal: =2.7.0 (Unicode 15) [x] (in-tree maintainence tool): Unicode version independent [x] : Unicode version independent (used by tool) [x] : Unicode version independent (used by , then ) [x] , , , : Not really Unicode version independent but we only use Unicode version independent part. They're outdated, current: 0.9.1 (CLDR 37, Spring 2020, ~= Unicode 13), would be nice if a new release is used.\nis , which is updated with the libcore update (or more specifically, this year it needed no update). is handled by\nI happened to notice this in the UCD spec It seems that as of 15.0.0 have to start parsing some of the comments to look for decls now. This is pretty annoying and will likely lead to some bugs (likely minor). I'm certain I've written code that would be buggy under this. (Hell, I'm not sure I've ever seen code that handled these, and I've read a good number of UCD wrangler scripts -- usually it's just to say \"assign the obvious default value to anything that doesn't get specified\", as in the line above) It looks like the only files in UCD that take advantage of this (e.g. use it several times to define a full range as having the obvious default case) are , , and (note: this is just the UCD, and I haven't checked stuff like the UTS39 security data, though). This doesn't include anything we ship in the stdlib AFAIK, but almost certainly impacts some stuff in the compiler (in probably minor ways, if it's limited to the above). I suspect the argument is folks we were always doing this wrong if they ignored it though? Oof."}
{"_id":"doc-en-rust-096256adf57abbf7a10b1baa1e9540f2e8b42b5c8e9c7f1dea117e17e24fba4c","title":"","text":"CC (since I suspect you know more details here, and even if not, I believe is yours), (since I noticed it while adding something to ucd-generate, presumably there are a few things in that might be impacted if you update its tables)\nThis seems like another reason for us to potentially switch over to ICU4X (maintained by Unicode), potentially with unicode-rs (or somewhere) maintaining crates of data output. Unfortunately it's unlikely will move to something heavier than the unicode-rs crates which have always stayed zero-dep sicne they're at the bottom of many deptrees. I don't have time to fixup unicode-width but would be happy to accept a patch.\nI think rustc doing that is probably very good. It's hard for me to imagine anybody fighting you on it. For the tables... presumably you mean inside the table generator (definitely we couldn't add a dep to libcore on icu4x). We could use it to query the data we build the tables with, instead of ucd-parse. That doesn't sound like a problem eventually. (I'll look into it soonish since I'm messing around with Unicode table generation again). For the ecosystem at large, I dunno. I suspect it will be a tough sell, due to compile time, binary size, and overall heavyweight dependency trees already being in the most common complaints.\nYeah for the core unicode stuff it'd probably be best done as a table generation. Worth noting though: you could still use the efficient code point trie impl that ICU4X uses for this, and not take on too many dependencies. Note that ICU4X's model also involves running a data generation tool; so it might not be an improvement over ucd-parse for us. Eventually, ICU4X will have a copy of various slices of data on a CDN, and then it would be an improvement over ucd-parse. The only difference right now would be that ICU4X is much more likely to update quickly to the latest unicode stuff over ucdparse, but that may not be a huge deal since ucdparse doesn't need much work. I wasn't really thinking about the ecosystem at large. I'm fine continuing to maintain unicode-rs, I just don't have that much time to devote to it."}
{"_id":"doc-en-rust-0ee0a744e8d45f065e920bdf8eba64e2a77ef934f464b67fb7bce4a8f30ddb73","title":"","text":"Overall rustc and other users tend to make PRs when they need them and that works out fine. FWIW, ICU4X is very much optimized for binary size.. Perhaps not compile times, but it does tend to produce small binary sizes (and it's shipping on embedded devices already). I'm not really pushing on us moving to ICU4X yet (I think is investigating a bit though!), I think the status quo is manageable, but it's definitely an option on the table!\nI don't think I have any strong opinions. It seems like could be updated to handle these declarations without too much trouble though? And then things would be fine? Or is there something else I'm missing? Also worth pointing out that the whole stuff is something I built for lack of a better alternative at the time. My goal was to get rid of an ever increasing pile of bespoke Python scripts. But I don't have much vision beyond that, other than keeping it \"simplistic\" and framing it as a \"kitchen sink\" of sorts. I've also updated 's README to link to ICU4X (wording changes very welcome):\nOh yeah to be clear, no shade on ucd-parse and ucd-generate! They're great tools and I don't necessarily mean to say ICU4X is much better or anything. Rustc already needs ICU4X for list formatting and was investigating using it for more things like the XID and security properties (which rely on those manual python scripts).\nI can't make heads or tails of the declarations. From what I can tell, they're mainly being used to apply property values to... unassigned codepoints? Just looking at the diff between Unicode 14 and 15 for , this text was removed from 14 and replaced with declarations in 15: So it seems to me like parsers of UCD that ignore in Unicode 15 are probably still just as wrong as they were with Unicode 14? The Unicode docs do a really terrible job of even explaining what is supposed to mean and why it even exists at all. The only explanation of what they actually are seems to be the first sentence of the section you linked: Most of the rest of that section is documenting the format. The key thing that's missing from the docs is what actually is and why it exists."}
{"_id":"doc-en-rust-9cd1a2097289d5974499455f2d77f63e6a89691630ec9fd085fe64c44c0c1376","title":"","text":"Like... why does there need tobe a mechanism for defining default values for ranges of codepoints when the files themselves are already defining values for ranges of codepoints? Something is missing from my conceptual understanding because I don't understand why the declarations aren't just converted into normal lines in the data files.\nI have some guesses as to what the answer is but I don't want to say something incorrect, so I've just asked these questions to the Unicode people.\nI'd like to hear back from contacts in case I'm mistaken (or missing some detail), but I'm confident I know what they're for, and have thoughts on them in the context of a low level library like . These exist because several of the UCD files do already require special handling for missing values, but it's not usable in a programmatic manner and needs hard-coding. I believe the goal is that for properties that have lines, you can now determine the property values for all codepoints using just the data programmatically readable from the UCD, without reading the documentation of that property. Here are most of the interesting cases I've found for this (some of which are more useful than others), which should give you a good idea of why it exists and why with very complex defaults, like . I believe this is intended to replace things like . Presumably this list in 's source should have have been getting updated to synchronize with the comments in 's header on each Unicode version update, but that comment didn't really indicate that it was going to change, so that was not happening. Now, these are in lines, which allows that to happen without manual work. I don't know if it changed before now (some documentation hints that it did), but I'd weakly recommend to the Unicode folks that when it changes, the and files are also changed to contain tests that fail if the updates have not happened. That may already happen, but that's really the only many people know if their parsing code is wrong for something like this. with a single default value. In most of these, the default is listed in that property's documentation (or prose in comments in the file) and is kind of the \"obvious fallback\" (often , if that's a value for that property). Now you can read line to determine that the default for is , that defaults to , or that defaults to , and so on."}
{"_id":"doc-en-rust-b361627a6821c2c961f83bb82007f70c2e6230b7c8d8969fcf06fc790ba929da","title":"","text":"An odd case here is that the empty string is spelled , but given that that's only used for a property whose value is a codepoint (and not an enumeration), it's unsurprising that it has a special case. , boolean properties which default to and only contain UCD lines when they're . There are a few of these in the normalization properties, and it is probably only useful for code that wants to handle things super generically, but that's something. that default to the codepoint itself, such as is the codepoint itself. Previously, you just had to know this (it's kind of obvious if you think about it, though), but now a line can be used. that default to the value of another property. For example, the has . This codifies that the default value for the property is the value that codepoint has for the property. There are some annoying things about this: a user of a library like (but definitely not for something high level like ), I might want to distinguish between \"this is a value explicitly from the file\" and \"this is the default from \". This is generally true for several of these, but especially true for a few cases like , where I may want to be handling values entirely separately. Obviously a high-level library for Unicode properties would absolutely not expose this distinction, but for something which is explicitly for parsing the UCD files, I suspect including values should be optional (even if it's done by default). now, the property value will often use a different property alias than is used elsewhere in the file. For example, a line for EAW uses , whereas the file uses . Similarly, uses / in but and in the file. Most of these use the \"long\" form of the property value in the line, and the \"short\" version in the file itself. I can see the logic here, but it's annoying, as to handle this fully programmatically, you need to read . 's incomplete and completing it feel like it might be a bit annoying. For example, still has \"All code points not explicitly listed for Case_Folding have the value C for the status field, and the code point itself for the mapping field\" which is not reflected in a line. Given that this is not a single property, it will probably require a special case for the lines."}
{"_id":"doc-en-rust-1679be179fd3b6a6e4a517d8e30d07ea29fe385fd66ac5fb81d5341f73e74a11","title":"","text":"'s also not clear which of these are \"stable\" values you can rely on, but I presume the answer is \"technically none of them, but in practice it's probably safe to assume something like on a derived property is unlikely to change\". That said, overall it's probably a good thing, but the release notes for this definitely ignores many of the reasons why this might be a bit of a pain in the ass to handle.\nTLDR: they make the files more maintainable and easier to read comments for\nSome more background from Asmus, including some explicit steps on how to handle them. They brought up an interesting point that the order of parsing them matters a lot."}
{"_id":"doc-en-rust-ffa80db9e721c264afb46e4b02c27fd4cf817d4c7e2ec371cb0a73e24a929b37","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: no resolution for an import', 'error: internal compiler error: no resolution for an import' 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: --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nregression in cc\nI believe the root cause of this issue stems from the changes I made, so claim"}
{"_id":"doc-en-rust-98eb13684346f5e5333a3a75504a07011b9182b5b3c4e93046181eb981ac791a","title":"","text":"Example: CC: ,\nThe error is emitted from . Adding does enable the example above. Interestingly, no terminator appears in the MIR for that function. This suggests that we are running const checks before a cleanup pass that removes terminators for exhaustive expressions. We have a few choices here. I am leaning towards just removing from the checks. What do you think? cc\nLet's gate the removal on for now to make sure we don't accidentally allow anything on stable.\nOh yea, I just left it in there so we don't accidentally allow something. I couldn't figure out how to trigger it, so I preferred to deny it."}
{"_id":"doc-en-rust-971b90aaf1316210c41e93f144e98b6981b2461b1128426fc3dcd08ac2a1f1d4","title":"","text":"No response No response No response\n(for compiler people:) We could fix this by merging the impl WF and coherence checks into one compiler stage. I'll put up a PR and see what T-types thinks.\nlabels +AsyncAwait-Triaged We discussed this in a WG-async meeting and are deferring to the resolution suggested above. He noted that this is a fix to the diagnostics only. That fact that this is an error is correct."}
{"_id":"doc-en-rust-dfb1853f080d636b0154a993ccc58567464750f8671998b9ed42ac8ff219ae7d","title":"","text":"More information on\nTo be clear, I'm not actually sure that's a private link, I didn't look at it in detail. It might just be doc(hidden) or something.\nI didn't either. Just that most of weird things happening are in ."}
{"_id":"doc-en-rust-5e99db89097748d7a5bb96727be9b26d8b479b8435a424d5e1140133f0406230","title":"","text":"I forget if there's already a bug on this, but it would be nice if, when you wrote and doesn't have a field named , but does have a nullary method named , the compiler gave a hint like \"did you mean to write ?\" It could also do vice versa (if you write A.B()ABA.B?) I ran into this in trans, where I have frequently written instead of .\nTest: The error message is better now than it was: in that it suggests there is a method named . But it could still be improved. (The intention may not have been to take the method's value; it seems more likely that the programmer thought it wasn't a method at all.)\nMy previous comment still holds. It would be great if you would see the \"try writing an anonymous function\" hint for something like and instead see a \"did you mean to write ?\" in situations like this one.\nI'd also like to see one when trying to call a function-typed struct field: emits Foof. It'd be nice if it tried to see if it could auto-deref to a struct field, and if so, say (f.f)().\nA nice idea. Assigning P-low.\nCurrently gives which is pretty close to the proposed behavior. Replacing the wih yields the same as before (i.e. does not suggest removing the ):\nUpdated the example gives: which now prints It's nice that the note is there, but the text is suboptimal: isn't a function.\nI'm working on a fix for this, but I'm struggling with the final portion. With this code: I get the output: My current changes are . I'm not sure if it's possible to have the output say \"\" and \"kitty.x\" with the input to the function. Any ideas? Or should I just keep the message in the same format as it is now and output \"s.func\" and \"did you mean to write ?\"? Edit: Ideally, I would like to output: I'm wondering if that's at all possible, especially because instead of , there might be an expression.\nI got around that error message. Now I'm making sure the previous message is displayed under the proper circumstances."}
{"_id":"doc-en-rust-75999ed6359ba009811e1f1f37debaf774484a43d5cae9a6436797ed38b50b2f","title":"","text":"Uninhabited variants should ideally be irrelevant to the representation, just like in enums. As a test, this prints out 0 instead of 8: This happens because rustc considers unions more like structs than enums, and the sees a single variant with two fields, one of which is uninhabited. I have a fix for this, but it's slightly easier to bundle it with some other changes I'm working on.\nThis becomes a problem when making an array of unions: The above code represents a regression (prints 42 on stable, garbage on beta/nightly).\nI didn't realize it was a regression to beta - in that case I'll put up an independent fix so that it can be backported if desired.\nAlthough I can't trigger it on the playground, you code is actually triggering an ICE for me: EDIT: I bisected the ICE to somewhere between \"rust 1.23.0-nightly ( 2017-11-25)\" and \"rust 1.23.0-nightly ( 2017-11-26)\".\ncc\nI put up a PR to fix this, but I'm still confused about the ICE (which I moved to )."}
{"_id":"doc-en-rust-ea5d4597e087d144986ec6fc4d7469cb0c68467fc4e06211f6297ba361262d0d","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<strongSample Backtrace</strong</summary<p</p</detailsThe original code () is already fixed by , however some other mutations of the original code still ICEs with the same backtrace and error. Thanks. <brCC <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nIf the parsing error is not needed to manifest the issue, can that be fixed () in the MCVE you provided? since more error messages just obscures the underlying ICE that needs to be fixed here.\n(also this could probably use a more descriptive title that reflects the ICE, and doesn't just point to another issue, but that's just my opinion)\nIs that better?\nclaim"}
{"_id":"doc-en-rust-c3671c5c542204733f5004e90c3051d2e845695aac5eaf4db1345e0506fc1d2c","title":"","text":"Currently, the beta binaries are only present in ; has only the standard library, not any binaries. That causes two issues: doesn't work with stage0-sysroot, meaning there's no way to change the standard library and use those changes at runtime without doing a full stage 1 build doesn't work. This is very rare to want to do, but can be useful when modifying the process itself, to avoid long compile times. Copying the binaries into stage0-sysroot is an easy way to fix both problems at once. Mentoring instructions: Add a call in which copies the whole directory from . <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nWe should also consider renaming to something else; the name is very confusing.\nclaim\nThe name is correct though. It is a directory you can pass in as argument to rustc.\nso is . I'm not saying the name is wrong, just that it's ambiguous and not intuitive. Honestly I would rather rename all the directories to and change to or something.\nis confusing too as already has a libstd. Just one from the bootstrap compiler rather than compiled from the current source.\nOk, then maybe :shrug: nearly anything would be less confusing than just appending IMO\nMaybe rename stage0 to bootstrap and stage0-sysroot to stage0, matching stage1-...?\nis confusing with the artifacts for , but maybe would work, keeping stage0-sysroot as is and renaming stage1 to stage1-sysroot\nReverted in\nI actually wanted to recommend something like this as an alternative std benchmarking workflow. Currently I have to suggest a stage1 build.\nI meant is very rare. I agree wanting to use a stage 0 toolchain with just the libstd changes is common :)\ndo you know when you'll have a chance to follow up here? If you're not planning to follow up, can you please release your assignment on the issue?\nSorry, I didn't follow this item recently. Ok, release it now.\nclaim I would like to take this issue up [with a bit of mentoring :)] if that's alright. It's my first time contributing!"}
{"_id":"doc-en-rust-0997532db3cf9cefb31852be8658f9c345c6a843ae643e010da48c030953ee9f","title":"","text":"thanks for looking at it :) the first step is to cherry-pick the changes in to the latest master commit. Then you'll need to fix the bug Mark mentioned in , which I believe has some more details in https://rust- I think it's enough to copy the user-provided over to . Feel free to ask questions here or in https://rust-\nIt was mentioned that reverted this so I am reopening this unless someone can point me to the, er, revert of the revert?\nUseful Links and Points for anyone who wants to work on this: Initial PR : Revert of the Initial PR : Attempt 2 : Revert of attempt 2 : If I am to understand correctly, the revert of the revert was rejected mainly because rust perf () broke. For anyone working on this issue again, here's a point to note: Just copying the entire parent to will not work as pointed out by in zulip as, suppose the rustc is installed in and you try and copy the underlying parent dir which would be . That time, will get all the binaries in . This will however work when the installation is in something like :\nMy suggestion would be to re-land almost as-is, except with this feature disabled when a custom is set.\nclaim I'll give this another shot then"}
{"_id":"doc-en-rust-0d3e58ce58bc2122f663187778037ad23504868bc4e7259dad3b9da77deeb0bb","title":"","text":"The problem is that the configure script assumes that all keys are in a section and there are no top-level keys. This forces people to use instead: We should make it possible to set top-level keys through , both and . We should also update the line in the readme linked above to suggest instead of printf. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nMentoring instructions: look around I think the fix would be something like .\nIn the , from where exactly do we get the top-level keys? from the set function?\nI'm not sure off the top of my head. How could you find out that information?\nHi are you still working on this?\ndo you think it's okay to unassign ? This issue is blocking as well.\nSince there's no response from the assignee, I think you can take the issue. Are you still keen on working on this issue?\nYup I am interested! claim\nHi and thanks for mentoring! Assuming I run , I think will be 2. So I am not sure if this path would work. It seems like the first blocker is that does not contain or as keys. Should the approach be to expand with those keys? Or should we just allow / as special cases? I am guessing it's closer to the latter, since that might affect the definition of which searches for . Finally, I am a little confused what top-level keys mean - do they exclusively refer to [, ] ? Are there more?\nI am able to expand when parsing to include and but I realise I may either have to make changes to or write a new method. Before I do that, I would like to understand how the configure script is commonly used. Could you give me some sample commands, say if I want to modify the field of llvm?\nShall we refactor the 2 top level keys under a section? this makes the parsing logic more consistent and unwieldy lol\nyou can take a look at for a complete example of what a configuration could look like. I think that would resolve most, if not all of your queries(: Hope this helps!\ntry running\nGot it, thanks I put up a PR. This is kinda my first PR so would appreciate all the tips and advice!"}
{"_id":"doc-en-rust-875a2786fcf527de391303718bda012a20b8c1f2bf5c7cea64da25946072c85e","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."}
{"_id":"doc-en-rust-5b251606875fac78e227cdf5c5daa286e1a89ecb4026e5bb4af0f3d4b835a0b0","title":"","text":"This should not compile, since is for some non- and thus will contain as well. It compiles fine however and results in the varying output depending on the optimization level (which shows that this is an UB out of the \"safe\" code). Tested with and playpen.\nA more self-contained example that shouldn't type-check:\nIt seems that this has been possible since generalized lifetime bounds went in.\nHuh. This was supposed to be fixed. I'll take a look.\nP-backcompat-lang, 1.0\nOK, simple oversight. PR coming soon. Amazing we have no test for this. It occurs only with coercions. (In general, this code path could be cleaned up, and will be as part of implementing generalized where clauses, making these kinds of oversights harder to do.)"}
{"_id":"doc-en-rust-07bcf664db0a7ec7a14cf7a951e84a641718230dd6e924cb7a4565d8925ee8d7","title":"","text":"These two errors, which I believe are related, have started happening with rustbuild recently. I think the second is sometimes caused by the first after trying to avoid cleaning out everything; but since this is all nondeterministic from what I can tell I've included it in case it helps diagnose the problem. cc\nA few more lines of potentially helpful information:"}
{"_id":"doc-en-rust-7923ab602461c65f999a12082ae1e882c4735fbee27f6eb17b2ee0a985d5e2bf","title":"","text":"Before the recent changes to rustbuild, when changing , it has rebuilt the entire stage0 artifacts and thus the entire compiler. Now its only doing: Later on, you are getting an error like \"found possibly newer version of crate which depends on\".\ncc note, I'm not using any --keep-stage stuff or anything.\nworkaround is to do manually\nI think this is the same as (or that's the same as this), haven't had a chance to investigate yet. My guess is that this is a regression from\nyes I think its the same issue. If you are closing dupes, then please close the one that was filed later :)"}
{"_id":"doc-en-rust-59b3c3403dd4373844f9a62da49c542697aaa7b63b1bcca0f96fb5648b6903bd","title":"","text":"Take any page in the Rust docs, for example . When you press the or keyboard shortcuts on your keyboard, they are supposed to either collapse or expand all items on the page, but not both (according to the instructions that you can find by clicking on your keyboard (or on the screen). Please make the + and - keyboard shortcuts idempotent, otherwise it would be redundant to have two buttons that do the same thing.\nWhat do you think about this ?\nYeah we should do this.\nI'll send a patch in the next days then."}
{"_id":"doc-en-rust-d5aaca454c4b9e374bf52fd688a570f38314b1b4372f475dd8a89626b2ac7ccb","title":"","text":"Users should use the cargo-ified Deprecate for a release or two then delete. cc\n:+1:\nRelated:\nI tried this: Hoping to deprecate the whole crate, but then building this program does not emit any warning: I expected a deprecation warning on the line. Is there another way to achieve this, or do I need to annotate individual items in the crate?\nThat should have worked, but you may need to remove the annotation above (they may be conflicting). I would also personally find it very helpful to annotate methods in particular what the path forward is (or just a general post about how to migrate).\nRemoving worked, thanks. Should this deprecation go through the RFC process, or can I assume that the team wants it since filed this issue? The documentation at explains how to use rust-url, and in particular the concept of relative v.s. non-relative URL schemes (e.g. vs ) which is a bit unusual. I believe this sufficient to make migration straightforward, but I’m obviously biased. Any feedback on the documentation is welcome. (I’ll make the deprecation message include the documentation’s URL, it seems more useful landing page than the github repo.)\nHaving an issue is sometimes considered a \"todo item\" rather than \"everyone has approved this\", you'll find both styles of issues on the issue tracker. We don't have much precedent for deprecating an in-tree crate, so we're forging new territory here. I'd like to start moving crates out of the repo, however, so I hope to have some more on this topic soon."}
{"_id":"doc-en-rust-8623cbd027f2dc19ea4face4f3b0bd210e45eb7918bf48101f74c5b8c593046f","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 requires debug assertions <!-- If 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 --\nlol, nightly emits this:D : another one from\nany updates? :upsidedownface:\nclaim I think I got a fix :slightlysmilingface:\nError: Parsing assign command in failed: ...' claim' ' I think I'... Please file an issue on GitHub at if there's a problem with this bot, or reach out on on Zulip.\nclaim"}
{"_id":"doc-en-rust-b73840ea4e47f23b52e55abe148348ade905c37101ff17ff6768ea2c63c1a9cf","title":"","text":"When writing the current error is \"expected one of these tokens\", without any attempt to recover the parse. It should instead be closer to: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nWhat do you expect the suggestion from this code? here is a valid identifier, \"expected one of these tokens\" comes when the second identifier comes.\nI think this case should remain as is. in particular is a shame because it is a valid type for the parser, but not a valid trait, and newcomers might not yet have a mental model for the distinction. I would say, when parsing a trait, if it can't be parsed, then try to parse a type in a snapshot (like we do in other parts of the parser), and if successful, emit a targeted error (trait expected but found type).\nclaim"}
{"_id":"doc-en-rust-2dd090760090ca0f8daddb4fafec4d253dc260bb78ca93011deb1a8511d1f616","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 compiler team prioritization."}
{"_id":"doc-en-rust-52ff78bb803c348d23865431fcf95aca9114b024ef3ad08fdb44f7d12198f25f","title":"","text":"The following code should pass regardless of the declaration order of lifetimes: This is related to but it's different in that we do have a lower bound region, , but we fail to recognize that because , which is responsible for calculating from , assumes that the outlive relation is a total order, which is not true. Here is the graph of : ! So we need an efficient algorithm that works for partial order relations, but the one that comes to mind is . The perf may not be really important here but I'm curious to see the alternatives. label C-bug T-compiler A-borrow-checker E-mentor E-help-wanted <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nHere is the code of concern The code should calculate the from a set of universal regions (). The relations are encoded in and are guaranteed to be transitive and reflexive. The relation graph may have cycles and can be sparse. The goal here is to find a unique minimum choice that is known to be outlived by all other regions. If none can be found, the function returns . Regions that have cycles between them are considered equivalent so we can pick either one of them as a unique choice. e.g. , we can pick either one of as a minimum choice."}
{"_id":"doc-en-rust-aeed43aa44c33dfb55c1c8ce58b0347fafb79af0feebbdc7e43f06227f1b1080","title":"","text":"Compilation backtrace Version Seems to be very similar to and , but the difference is trying to send the value over a channel (removing this gives a \"cannot move a value of type [u8]: the size of [u8] cannot be statically determined)\nJust to update after the 0.12 release. I tried compiling the above example and am getting the same result (so this issue is still relevant).\nReduced test case: Something about the closure lets it get past type checking when it shouldn't.\nThis looks simple, I'll hopefully have a PR shortly.\nClosed by"}
{"_id":"doc-en-rust-2ec5dee6453ac67ff14b24b63e8a1e5a93825fe2dc24753c7e72b30695c7f453","title":"","text":"In , it was uncovered that is making some rather strong assumptions: two s with different address but the same type must not overlap. Not only is this a scarily non-local safety invariant, it is also fundamentally incomaptible with some APIs that ought to be correct, as demonstrated by this snippet (thanks to and for help with working out the example): to see the issue: will duplicate parts of the memory range when there is overlap, which leads to double-drop (other parts of the memory range are just lost, leading to memory leaks, but that is not the main issue here). This is not itself a soundness issue as it requires unsafe code to trigger UB. But this likely reflects an unintended consequence of . This got stabilized in as part of That commit references and an RFC, but is not mentioned in either of them. was in Accept that is unsound and document \"non-overlap\" as part of the safety invariant. This seems very fragile. Make not misbehave on overlap, either by panicking or by only swapping the non-overlapping parts. Cc\nwas in , which was authored by a \"Charlie Fan\". This is probably\nCc\nThis makes the method sound, but it seems like there could be other seems-like-they-should-be-ok cell projections that break under this behavior.\nI don't think so. This makes the function behave \"strangely\", but since no data is duplicated nor discarded, I think it is sound.\nI share this hunch, although the code, out of nowhere, may look very contrived. Consider: So it seems like -king (at least for non- types) is the only option that would allow us too keep the structural property of s, which, imho, is a very intuitive programmer mindset (and thus, a mistake that many would do should they not know about this caveat), and so a quite important thing to preserve .\nThat is an example of the \"strange\" behavior not being the right thing for this code, but it is not an unsoundness of per se. Your unsafe code is simply making wrong assumptions about the functional behavior of . Current favors the first operand in case of overlap (according to documentation); unsafe code that incorrectly assumes it would favor the second operand would be equally wrong. I don't see a bug in either way. IMO it seems rather strange to only panic for non- types."}
{"_id":"doc-en-rust-a4b7c0175f8911b861196ef37fe4f352c3fad5d4d87fe55100f0c4c481d1f11b","title":"","text":"Btw, also exists. does not have array/slice projection functions though and they would be wrong due to the counts, so overlapping probably truly are not a thing.\nAt the very least, an argument that aren't allowed to overlap is easier to defend than that aren't allowed to overlap. Plus also, doesn't have guaranteed layout in the first place, so any example using tuples is (currently) implementation-detail-tied even before hitting . You could still construct an example using only types, of course; just replace the tuple with an actual type. You could even make it . As I understand it, there's three main cases here. ping two nonoverlapping is fine. ping two partially overlapping without any bound on has a sound, if surprising, definition, where the nonoverlapping part of the arrays are swapped. ping two partially overlapping unknown is unsound in any definition, unless both has no safety invariants and the overlapping portion is . The third case is obviously the most restricting one, and is defined on . To expound on first of the two subissues: Consider a type with the extra safety invariant that the second must be double the first . could even be . It would be valid to create two from , as you'd have and . There is no possible definition of (other than a no-op) which preserves the safety invariant. And of course the impl doesn't even know about the safety invariant. I could probably create an even worse example using underaligned types and relying on a specific endianness, perhaps even accidentally breaking validity invariants (think around partially overlapping ). The only two resolutions I'm confident in are making always panic for overlapping cells (because there could be safety invariants being broken) or forbidding overlapping s to -compatible types (optionally: that would be broken by ). And I don't like the subtle implications of the latter (e.g. being unsound for unbound ).\nI don't think would be immediately unsound, you would still need a way to create overlapping s.\nIn particular, they certainly can only overlap in restricted ways -- if they overlap such that one's sits on the other's , I can already cause UB without just by storing into that and then reading it as a . Oh I see... to only swap the non-overlapping parts we have to make an argument that these parts have the same type (safety+validity invariant)."}
{"_id":"doc-en-rust-ca1fb55f9ff9f81dce50946c9294ead6c8b65c0c9f1846bd21a3af78d84c40f8","title":"","text":"Which... seems utterly bogus now that I think about it. Worse, the invariant could correlate the overlapping with the non-overlapping part, as in your example. (Removed a whole bunch of nonsense where I try to find some special cases that work.) Yeah we should make it panic.^^ It is unsound to create an to these though, even without I can already violate the safety invariant here by setting the second reference to . Ergo this is not a problem for , we can already assume such references do not exist. I am confused, is there a negation missing somewhere in this sentence?\nFair. I'm fairly confident that it'd be possible to come up with some safety invariant that a partial swap would break, though, with more data-dependent qualities. The parenthetical is an optional relaxation of the potential requirement (but at the cost of a lot of complexity).\nBut shouldn't it be forbidding overlapping s to -incompatible types? Not that I know what either of these things mean, but forbidding incompatible seems to make more sense than forbidding compatible.^^\nYeah, poor verbage. I meant roughly \"forbidding overlapping s of types that can be used in (i.e. sized types)\", with the optional extension of \"only for those actually broken by \" (however that would be defined).\nthat partially overlapping s through an enum is problematic even without :\nEnums isn't really the same thing. That enum projections are unsound , but as also discussed in that article, struct projections are typically ok, and the array projection discussed here is essentially a struct projection, not an enum projection.\nI would like to bring up my crate  which allows projecting through using a macro. example usage: Note: doesn't allow projecting through enums for exactly the reasons that explained. I'm not sure how could interact with to produce bad behavior, because you can only project to fields, which can't be swapped with their parent, but just in case someone else finds something interesting. i.e. This isn't possible, so it's not possible to project through to a field that's the same type as the parent. Alongside the fact that all fields are disjoint means that cell-project should only produce overlapping if they are also .\nI agree with here. Sum types and product types are different, and really should commute around product types, i.e., ought to be sound."}
{"_id":"doc-en-rust-b6f6cf0827c572b75d97b4e21eff6feaf65504809c34cb4ad9302d547666ce03","title":"","text":"You can use , which led me to this issue (it'd be good if we could support field projection inside of and ).\nWhile you could use to check that the tuple layout conforms to the C-like layout needed to do such projection, I don't see how your specific use of would lead to two partially overlapping though. Note that the problem is not with projecting to a single field, but to a group/subset containing multiple fields (or like in the array/slice example, to a subarray/subslice with length ).\nOh I see, you're right. False alarm."}
{"_id":"doc-en-rust-e8d1a87ff32fd398eadeb80d27309f0ef25203d4671689492705d3e1da736620","title":"","text":"While reviewing I noticed for the first time that the improperctypes lint normalizes with the \"revealall\" mode. I don't have a nuanced understanding of what that means exactly but based on the general description in the rustc docs and experimentation (see below) I think that's probably the wrong choice for this lint, because it exposes details to the user that are normally hidden during type checking. For example, using existential types, the lint pierces through otherwise-opaque existentials to look at the underlying (hidden) type, thus it both accepts code that is only FFI-safe because of the particular type underlying the existential, which users of that type shouldn't know or rely on leaks the underlying type to the user in error messages when (correctly) rejecting uses of an existential type as FFI-unsafe I can't quickly find an equivalent using only stable , because we don't have , but if there's a way to write \"Option of the return type of this function\" in stable Rust, then that would presumably have the same issue. cc for fact-checking my understanding that this is because of reveal_all\nUser-facing diagnostics should avoid the mode, yeah. In fact, the other variant of is literally - also the doc comments are pretty explicit about this: cc\nI've been using 's over in recent PRs that modify the lint (see , , and ). In each recent PR, I've ensured that opaque types are prohibited (in the spirit of \"FFI-safety of a type not relying on particular type behind an opaque type being FFI-safe\") - with the exception of when a opaque type is used in a projection (). Unless there are specific examples of behavior that still need to be changed as a result of this issue - should this issue be closed?\nMy litmus test for closing this would be \"all the normalizing done in improper_ctypes uses \", which is hard to audit for while there's multiple PRs in flight that address parts of the problem. After those PRs are all merged, we can see if there's any remaining and if so, their location should tell us how to exercise any remaining questionable behavior.\nI've opened to fix the remaining two places that is used now that the other PRs have landed."}
{"_id":"doc-en-rust-7041623637e60720121892113e26d42cd0f2ee4ad12f7507749f6c0b2fa95336","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 regression of cc\nBefore I create a fix: is an expected/reasonable value in this ? I.e. is the right fix here just to allow ?\nI don't think so. Actually just looked, think it's because we're not erasing properly. Let me put up a quick fix."}
{"_id":"doc-en-rust-ff59e9541a0d52181662510875499f6cbc9629ee449eb6bbf9552e9a4e66d7a1","title":"","text":"It would be more helpful to suggest the method for the typo rather than a nightly-only symbol which isn't actually available. the suggestion doesn't work. method is actually available on a . method has been stable since 1.0.0. had trouble noticing the difference between and and could have used the compiler's help. No response Reproduced with 1.68.0 stable and 1.70 nightly. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc\nclaim"}
{"_id":"doc-en-rust-ca00de11c48bd8122f3ffd09c29271e6b6fc8ca7ea1d1c06a10d7c9a2a6affb2","title":"","text":"Error: Reproduces with:\ncc\nI just now noticed that does not actually yet allow unsized . Might be related.\nThis doesn't compile, but it doesn't ICE.\nIt looks like no longer exists. Did it get replaced by something else? I imagine there's not much value in adding a regression test with a broken import\nfrom"}
{"_id":"doc-en-rust-4af54f5024e9d4f362891c3a7af5a8b5184534c84fe80899b06445db2044e051","title":"","text":"When running on of the crate, panics: Platform: macos\nFYI, this appears to be a macOS-specific bug:\nMinimal repro:"}
{"_id":"doc-en-rust-2117c29f4bd8913f03832bd4148b56b6d548d806460c70ac387c75f8d0672cb4","title":"","text":"The title already says it, but as an illustrating example you can have a look at Since &mut T can be implicitly converted to *mut T, I wondered whether there's a reason that it doesn't work for &mut &mut T (besides \"no one has implemented it\" :smile: ). pointed out that this might be (in IRC). The example code also illustrates a somewhat unexpected failure of type inference, which might be worth filing as a separate issue.\nHmm... take the following: Rust will currently complain about mismatched types for the second coercion. It's not clear such a coercion should exist: it's like converting a to a .\nNote that first coercing to instead of seems to work ().\nYour testcase is constructing a , not a .\nAh, thanks for pointing that out.\nIn don't know if I understand your point, but if you argue that such a coercion should not exist because it might be unsafe, the line in my original example shows that this conversion is already possible in safe code.\nHeh, C++ has special rules for multi-level pointer conversions exactly to prevent these kinds of type unsafeties: \"More qualified\" relations can be translated to Rust's // relations.\nisn't doing the same thing: the outer is actually constructing a temporary, so you end up with an (as opposed to a ). Also, safety isn't really relevant; we allow arbitrary explicit pointer casts anyway.\nOh, wait, I see, you expect the original to interpreted as , and then converted from there to . That makes sense.\nI think this would work if borrow expressions would take into account that they might get coerced later and pass down the from (where here), instead of only working for .\nTriage: this still reproduces.\nClosing this as the bug is fixed and playground link above works for all editions.\nThe playground link had the problematic line commented out: It still gives a compile error:\noops my bad then\nThis idea has been suggested. A T-compiler member has pointed out that other languages apply rules to restrain pointer coercion, specifically because multi-level pointer coercion is prone to being a bit of a footgun. Not quite \"this is a bad idea\", but despite the simplicity of the proposal, it deserves being treated with caution. There is no strong argument that this is a bug because it is consistent, if annoying."}
{"_id":"doc-en-rust-ddc41e3c675bcec624d7138668d58a699ac42a32b987d965f581c0e1d166c8b3","title":"","text":"Legalizing this behavior with narrow cases seems permissible, but amounts to a new language feature design request. Transitive coercions, as part of the revised coercion rules, are . Accordingly, I think this should also be closed... but not before documenting the current behavior in the form of a regression test."}
{"_id":"doc-en-rust-0ad2876dec5c6edb17baf96134b78f547b53e1708b15417c59a980f0ead14f4c","title":"","text":"In 1.12, figures out which libraries it needs for external LLVM using which breaks if you have LLVM with and (which is needed for clang 3.9 these days), since then there is a dynamic and lots of , but the code sees the and decides it has to link statically, which fails. The code should decide whether to link static or dynamic first, and then call resp , to get the correct library name.\nThanks for the report! Sounds like it should be a relatively easy bug to tackle as well!\nIn Void, we work around it by just adding , I guess for a general fix you need some policy how to link it.\nOh we basically always want to link LLVM statically, so we can probably just always pass it.\nWe emphatically don't want that in distro builds. Would you accept a patch to make this conditional?\ncertainly!"}
{"_id":"doc-en-rust-79c36807645d36c24eb732c4e5fa262f05ab5f12fb494a51f77bed52bd3cdebd","title":"","text":"When there was a change in a or other non-rust file, bootstrap tries to format it, which makes rustfmt very sad. cc and who broke this in <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI think we just need to filter .rs files before passing them to rustfmt.\nThis will probably be hit a lot by contributors so I'll pin it for better visibility.\nclaim\nNormally, the walker already filters for files, per Maybe the crate docs are not fully up to date, or I didn't understand them correctly.\nThe workaround is to run (notice the dot at the end of the command).\nI think if we add it like this: will always not ignore it anymore.\nMaybe try to put the part I before the ignore part, maybe this makes the ignore list work again? The thing that intrigues me the most is the fact that the files are not ignored later by the file type filter.\nFor any Rust files we changed locally, our current solution will try to format it, in some scenarios we may not want to format it, such as some files in UI?\nSeems right, my current fix is not completed.\nI think since you explicitly add the files to , that overrides the types filter.\nfrom my local experiment, seems is still expected, I changed some files which ignored in , they are actually not sent to formatter:\nWG-prioritization assigning priority (). label -I-prioritize +P-high"}
{"_id":"doc-en-rust-bfcef229268ab132206e13379ee4cf5df4e7dea3f90cab3fb01350431e065876","title":"","text":"The following code works in 1.56.0 but crashes 1.57.0 as well as the most recent nightly &mdash; . <details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nAccording to cargo-bisect-rustc the regression is from &mdash; FYI regressed nightly: nightly-2021-09-06 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.1</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nSeems that this is duplicate of and ; only triggers with incremental compilation enabled. Unfortunately although I authored the original PR, I don't know a lot about incr-comp or the query system to diagnostic the issue. label: +A-incr-comp\nFound the bug, I'll put up a PR in a sec. claim\nreopening as this is a stable-to-stable regression, and (I think) we keep those open until a fix lands on stable or we explicitly decline to fix.\nwas this backported / can we close the issue? :)\nThe fix was backported and released in 1.58.0\nPerfect, thanks for checking !"}
{"_id":"doc-en-rust-55640600d85eec7954965de1285b0e8eb6a6cfa88fbf78489cfc11ce8b33a971","title":"","text":"The Unicode Windows API internally works with (potentially ill-formed) UTF-16 paths that must be converted to from Rust's UTF-8 strings. The conversion happens here: does the translation from WTF-8 to UTF-16, leaving a with . The following calling to will then allocate to reserve additional memory for the null-terminating character. This could be resolved in two ways: 1) Call beforehand and then call on EncodeWide. 2) Make a wrapper around that increases by one. Incorporating the final null byte into would add a performance penalty, therefore it would probably be desirable to just adjust the sizehint by one and adding the null-terminator manually. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nIn the interest of enumerating possibilities, there's also using (hopefully this will optimize): Or we could test the for nulls before converting.\nThat's a good idea! Chain actually gives an example for windows paths: Although I'm not sure what's more efficient here, std::iter::once or [0]? Allocations are quite expensive so I believe the additional check (if it's not optimized away) would be worth it. However I also discovered a deeper issue. The sizehint that originates from the WTF-8 iterator is in UTF-32 code points. The lower bound will be (assuming that all code points are U+ or higher), the upper bound is (everything is \"ASCII\"). When collecting into a vector, the lower bound is chosen as an initial capacity. Since you almost never encounter paths that consists of U+ characters only, the estimated lower bound will always be too low and 4 allocations are required if the path is ASCII only, 2 allocations are required if the path is UTF-16 only, and 1 allocation is required if the path is UTF-32 only. It might be worth a consideration whether to call , as that would be a sane default (on the assumption that the majority of paths are UTF-8). However, this might waste some memory, do we have any idea on whether paths created from this function are primarily used ephemerally?\nI believe all uses of are currently ephemeral."}
{"_id":"doc-en-rust-3d4997bffc05d7a677a859f8e9df118e151605cfb0f6970977b5cec0858a5819","title":"","text":"We tend to use it only for as long as necessary to call a Windows API. There are a few places we keep wide strings around longer but those don't use as far as I can tell.\nIn light of that, I believe that the first solution would be the best. Solution number two would make naming very awkward (EncodeWideWithNul?). And while your solution is very elegant and correct, it would still mostly under-allocate given the interaction between size_hint's lower bound and collect. However, I find both solution 1 and solution 3 acceptable. It would be good to know how much reallocation actually costs and if it even matters at all in the context of interacting with expensive IO.\nI do agree implementing solution 1 would be a good idea. Having some good performance numbers would be great but I do suspect reducing allocations would be a win here. I would also like us to use stack buffers more, similar to . and only use new allocations when necessary. But that's perhaps another issue.\nReducing via stack buffers is a good idea, but I think it's out of scope for this issue. For now let's just reduce regular allocations, that should already give us some improvement! I'll try to see if I can implement this one. claim\nFixed by"}
{"_id":"doc-en-rust-f5326e22f71cdd34eafb993a416cbd08c44acc9b84d45622030dff5f24601a2a","title":"","text":"Rustc's parser does not include a loop's label in its span. So the span associated to the expression will contain only cc"}
{"_id":"doc-en-rust-8e5a735c622cef166c046aa07e45ca2b5f80785bd9fe853329a8782c17e1e87f","title":"","text":"eg It's still an accurate characterization, but there's no other kind to contrast with.\nWe probably don't need it to say \"Use with the module\" either."}
{"_id":"doc-en-rust-20cc63753de58077917485592c61d386f0463e11d828b715f80bd90c608309c7","title":"","text":"Testcase: : : Output: Should output, instead, the parse errors from . Probably misplacing the diagnostic emitter somehow, when creating the nested parser for the included source, and doesn't have an .\n(I suspect this is an easy fix, but am not quite sure)"}
{"_id":"doc-en-rust-fc9b844fe091b76e466cceb236948fdb6d2133850170a3d2244ea4deb2c5a59d","title":"","text":"When I tested 1.40.0-beta.5 on , never completed on . When I run that test on arm directly, I get: The same happens when I use official builds of Rust 1.40-beta and 1.41-nightly, so it's not just a problem with Fedora's build of rustc or LLVM. This test didn't exist before , but running 1.39 on the current test just fails even earlier, as expected, \"entered unreachable code: catch_unwind should not have caught foreign exception.\" I tried compiling the C++ part with GCC 9.2.1 and Clang 9.0.0, both with the same result. That's using libstdc++ either way though, because we don't have LLVM's libc++ available. cc\ncc\nPS: while I initially saw this on Fedora rawhide, my followup testing has been on stable Fedora 31.\nThat is very strange. And this behavior only occurs on ARM? I'm tempted to say that this is a bug in GCC's unwinder (in libgcc). Can you try this C++-only code to see if it has the same issue? a.cpp b.cpp This should print the message once and then fail with an uncaught exception.\nYes, the other arches completed and passed that test. Needs for , but then it works:\nI tried stable 1.39 again commenting out the call to , then gets stuck in the same \"caught foreign exception in catch\" loop on the C++ side. In fact, this happens on every compiler I tried back to 1.13, which is the earliest I could get working at all! So at least it's not a new problem. Maybe we're generating bad unwind data, or maybe my libgcc has a bug in handling foreign exceptions, I don't know...\nI think this might be a bug in the way the personality routine in libstdc++ (libsupc++ actually) handles foreign exceptions on ARM. Can you try using libc++ instead of libstdc++? Just change the linker args for rustc from to .\nOh, I found that Fedora does have libc++ packaged, and . But when I tried to use it simply as you indicate, foreign exceptions don't seem to be caught at all, in either direction."}
{"_id":"doc-en-rust-d66222edec83a3e517eeccf9b92162a84e4fe2da3c55f21965aa78504c19d4da","title":"","text":"I see the binary still gets linked implicitly though, I think because adds it to std. I'll try to get a full build of rustc with just libc++ instead.\nIt's fine to link to , since that contains the libunwind implementation. The actual C++ personality functions are in libstd++/libc++abi. Can you post the test output with libc++?\nMaybe this is obvious, but I have to compile the C++ part with clang++, not g++, or it gets \"undefined reference to \". I wasn't sure whether to also use , but either way the C++ exception is not caught by Rust: So I commented out again to just try :\nyou may need to explicitly link libcxxabi depending on how libcxx was built. That should fix undefined reference error.\nI did use -- do you mean more than that? If anyone else is interested in arm-linux, it would be great to get more hands on this, because that target is not a high priority for me. I will probably disable this test for arm in Fedora in the meantime.\nI managed to reproduce this on Arch Linux with , so it's definitely not a Fedora-only issue.\nno, that should be fine. Guess passing to the Clang (supported since 9.0.0) doesn't help either?\nThe link error was only when using g++ to compile That much was ok with clang++. I just tried adding to the clang command too, but got \"argument unused during compilation\".\nI'm hitting this on Debian too. Running by itself does result in infinite-loop printing however the rust test suite is actually running . Directly running this however exits immediately, so I don't know why the test is hanging. I'll see if I can grab the environment from next time.\nAh nvmd, I just had to wrap the thing in single-quotes to reproduce the loop, the output of \"pstree\" is misleading.\nSince this test is new in 1.40 I'll just for the time being in Debian.\nShould be fixed by"}
{"_id":"doc-en-rust-b8281b1451b797be2ffce462ed4ef0d603d40d0d3a2166c163a60479aa900106","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: ! Instead, this happened: ! This is issue from First screenshot is of and second is of\nProbably , it shouldn't have affected glob re-exports but maybe did (cc\nTaking a look.\nSame issue with a simple reexport:\nThat's what was meant to do, it wasn't meant to affect globs though.\nI think there is another issue with how it's handled because nothing is listed on the item itself too: !\nOk so it's the expected output for a non-glob reexport. I wrote the fix for glob reexports, just need to add tests.\nLatest nightly fixed the issue for but it didn't fix the issue for . In latest nightly below example doesn't work its last working version was also .\nNoted. Sending a fix for it as well. :)\nFixed in"}
{"_id":"doc-en-rust-f73158d12088b85532de80e8993b95975e895b595acb73f97c12468715d91ba8","title":"","text":"This appears to now be fixed.\nNeat! Just needs a test if there isn't one already.\nThere's , but I'm not sure if that qualifies as testing this in particular. If not, I can add one.\nMarking as E-needstest. I don't think the test I linked previously really fits this case."}
{"_id":"doc-en-rust-a1127d3791dc6f490ee8bb2aba82e535f02b093eb992f6f78003f733a6201bf7","title":"","text":"When I do , it says: Strangely, when I do , it uses the correct name: No idea how it is even possible for this tool to have two different names inside bootstrap...\nI think this is just because cargo-miri's tool check step is generated through a macro this macro generates the check message via there's a in there too. The build step has a different name because that macro explicitly asks for a display name\nIf I make the macro use a display name,\nAh, I didn't realize those two steps were defined entirely independently.\nAnyway, should make this more consistent."}
{"_id":"doc-en-rust-c89c683674199e3b48a2c460c25e7b5f71f38c6db0a6ad780b9fdf0e73a0d405","title":"","text":"should always return . But it doesn't if you enable the lvi-cfi feature. The miscompilation only happens with opt-level=0. Compare: Here's a slightly reduced LLVM IR: Difference in output when adjusting the lvi-cfi feature attribute on : . I can't really see any obvious culprits. I want to file an LLVM bug as well but I don't have an account. cc\nI think the Rust calling convention may be using whereas LVI-CFI assumes it's unused?\nActually you can see the issue in the assembly diff I posted, lines 45-51.\nI've filed an LLVM bug now based on this reduced example:"}
{"_id":"doc-en-rust-c9272f22dbff022b76cc904a2e597f2aa2588cb65afe57d99a14b694adccd85a","title":"","text":"Do you have a testcase that reproduces this problem? Also, what version of rustc are you using?\nI'm sorry late for your comment. $ rustc this is bad my code. : : rustc 0.6 ( 2013-01-20 20:35:24 -0800)\nFrom my cursory glance, multibyte characters (Hangul in this case) seem to cause this bug.\nNot critical for 0.6; removing milestone\nSeems to be fixed. Checking in a test case.\nDone pending\nTest case in , closing"}
{"_id":"doc-en-rust-6a6894a2ad5c2ccf4a08b81e572eb097c2539e018464c3298c4d31a097aecbd1","title":"","text":"I've been playing around with today, and it comes in super handy in blocks. However, it seems to run into issues when combined with the feature. I tried this code: I expected to see this happen: the code should compile just fine. Instead, this happened: This is a continuation of the discussion . As , this code (following the from the label-break-value RFC) compiles: : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nSo the error is generated here if I had to guess, I would assume that this function ought to be modified to check whether the and, if so, not to emit the error. (See  rust docs for a bit more info.)\nTagged as E-mentor since there are some instructions above.\nclaim"}
{"_id":"doc-en-rust-a25d4e9653f1c53e5b17ae87f6190030e3e6954fab24fa5d76102fd6b611edc2","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 attach a tarball with a small reproducer (few dependencies from , lock file, empty ). Now run this using rustc 1.56.0: I expect the sha256sum to be the same for the libpalette so file but it's often different. This breaks any binary caches, similarly to what did but that ticket turned out to be a problem with the crate. This time it seems problem with itself (or rather LLVM: stay tuned): 1.55.0 produces same binary/crate hash on every build. Note that in there's: Without this, the issue does not present itself. This perhaps makes it look similar to or but I think it's different. As far as I saw, it didn't produce a difference in ordering of symbols in the resulting though I may be mistaken. Please feel free to close as duplicate if you deem it to be the same issue. I have ran with and after careful sifting through few GiB of output, I found the differences seem to start in . I have bisected itself and ran it on our original code which exhibited the problem. I started the bisect at common merge point with 1.55.0 though the problem turned out well into the 1.56.0 release: cc who did the update : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nOne thing I found: if I run it with I can't reproduce it anymore. claim\nWell, I was wrong. Still reproducible even with . Produced files are identical though.\nConsistent with my findings with as well.\nUpdate: this IS a LLVM bug, I'm able to reproduce it with just ll input file using mainline LLVM. Filed to LLVM.\nI have a fix: Do we want to apply it to llvm-rust or are we going to wait for LLVM review?\nGood job, thank you!\nI wonder if rust needs too.\nAnswering my own question: it does.\nCould you also do a PR for\nSure, will do."}
{"_id":"doc-en-rust-76e5c4b36dd9fd53e030ad139e7c2ee81df179f07d252db8a79f59b78f496f7d","title":"","text":"Created\nActually I was too slow, there is already\nFWIW, while taking the 1.56.0 source and applying the 2 LLVM reproducibility patches fixes the issues we have with Firefox, the latest nightly doesn't: there's a remaining reproducibility issue on i686 linux. I'll test a patched beta next.\nThe next beta release should be fixed, per . (Should go out near 00:00 UTC -- I guess it will be .)\nthe beta branch + the patches seems to fix it, but I've found something new: depending how llvm is built, the result can vary. Specifically, llvm built with a sysroot exhibits reproducibility issues that are not present when not building with a sysroot. I'll wait for the official build for 1.57.0-beta.4 for a definite answer whether the issue is fixed. One thing is sure, though, there's an additional regression in nightly.\nSo, as far as Firefox is concerned, everything is fixed in the latest betas. I did find a source of non-determinism that is not fixed, but a) it seems to also affects clang (as in, I also have found one in clang, and I think it's the same root cause) b) it goes away with PGO, so it doesn't actually affect Firefox.\nis there a ticket about this one somewhere? It's great that it doesn't impact Firefox but it may be impacting other rust software\nI haven't filed it because the smallest reproducer I have at the moment is \"build firefox with these flags and observe how sometimes some functions have an extra mov\", and from experience, those don't lead to any action.\nI see, thanks. It sounds like binary-reproducability thing and ABI should(?) be the same at least. And this is a regression in new LLVM version (rustc 1.56 and beyond)?\nI don't know if this affects rustc, but I narrowed down yet another source of non-determinism in debuginfo, and upstream came up with a patch:\nWe tried using 1.57.0 and it seems broken still. I'll try to get a repro tomorrow. Should I open a new ticket or will someone reopen this one?\nActually, seems it comes from a derive crate in our dependency tree, similar to what we saw in ; So maybe it's fine."}
{"_id":"doc-en-rust-7b8289761f94e50a449885b4afa1f705bd72e9fe9f1c3ade580d1c7ddec0f660","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 compiling on an Apple M1 processor: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nCan also reproduce this when compiling on an Intel Macbook\nI've encountered the same error on a different platform (x8664) when compiling . The project doesn't use cargo so repro is nontrivial, but from I can see that the ICE started occurring at which is a rollup of . <details<summary<strongBacktrace</strong</summary<p</p</details\nAlso seems to be hitting starlark-rust, , as per\nSomewhat minimized standalone testcase: Builds on stable, fails on nightly. cc\nThanks for the minimization! Seems like we've hit again, but through a different code path. I'm investigating.\nI think might be another duplicate of this, triggered when compiling the crate."}
{"_id":"doc-en-rust-127ec8bc25a2afdf8e9f5817ddbaa0ef3a2cb2f7097dce45b0cc5cd164bd9c6c","title":"","text":"There are bad (404) links in search results with nightly rustdoc. E.g. go to and then click the result. This leads to which does not exist. Cc\nActually, this issue seems to exist even on stable -- somehow it went unnoticed for quite a while, it seems.\nI think it's because we are badly handling a reexport/type alias.\nI think this is a duplicate of"}
{"_id":"doc-en-rust-db79b2ced653864a414b12419c062a4fd008655c98d86ac17cc4bf3f6ae47fab","title":"","text":"This code, when compiled for , results in an ICE: Putting smaller integers in does not trigger this, even if you use a ton of them. Edit: It also does not occur when taking it only as argument, or when only returning it. Panic message and backtrace: Rust version: cc\nLooks like this could be caused by this common skipping of padding arguments: Combined with this call (which internally also skips padding arguments): When the latter gets used, each padding argument is skipped twice. I assume this is fallout.\ntriage: P-high Beta regression. Has pending fix."}
{"_id":"doc-en-rust-251b4f6db17392542a065e0e14d732d0058b589ab78b025210d97f8e8c18395d","title":"","text":"When a type has no impl, it fields appear to be destructed in order of declaration. When a type does have a impl, that order is apparently reversed. This is very surprising. Example: Prints:\ncc who first hit this bug.\nThe LLVM IR for the Drop glue for : The LLVM IR for the Drop glue for : I don't know why it's getting pointers to each field before calling , they're not used until the cleanup, and they're cleaned up in reverse order. It's also, for some reason, grabbing a pointer to the drop flag (), even though it doesn't use it.\nNominating. Seems pretty strange.\nI have an approved commit for this already, it's just failing on the pretty-rpass test at the moment.\nI'm OK with disabling the test. Going forward the pretty printer should mainly be used for compiler diagnostics and rustfmt should cover the reformatting use cases, IMO."}
{"_id":"doc-en-rust-611980ae0c7d5534a2f1f2d0f742fa1e7a532d2d71531cd1fb04c5b1fb6a2793","title":"","text":"This used to work fine at some point, but now leads to some strange errors:\nsomehow Miri searches for its sysroot in instead of its own built sysroot?\nWhen executing Miri: I thought the sysroot was passed to the process with , but I cannot find such an argument... how exactly does it find from this... I don't really understand how that works. But this may help.\nI see, it gets the sysroot because is in . Slightly strange, that sysroot is not really one it can use. Why is it linked from there? But either way, the sysroot we want to use for Miri here is an entirely different one that needs to be override manually. How did that work previously?\noh lol, this was almost certainly broken by , in which you even specifically mentioned , looks like you forgot about it :D\noops thanks for fixing!"}
{"_id":"doc-en-rust-ae7756653024b37944631061b04002bb6639e4d51af6f74811edbc5db7f3ecaf","title":"","text":"We've recently begun testing Bevy against the beta toolchain, where it has incorrectly raised an lint against . is not imported in this file, yet rustdoc believes that it is. (See the imports .) As a temporary workaround, I've created to ignore the error. Here is that first failed. In case it expires, here's . Look at . I can reproduce it on using by running the following command: The is optional, but it makes the command finish quicker. I'll continue testing to see if I can create a minimum reproducible example. :\nI've created a minimal reproduction in my -repro branch of my fork. Go to the  folder and run . I've managed to squish it down to this:\nI've created a reproduction that removes the dependency on Bevy . I've simplified it down to this:\nI bisected it, and this bug appears to first be introduced in . I could not reproduce it in ."}
{"_id":"doc-en-rust-4cabe525e8bd65c1784b54acf748f2e1483eb31241627e1b563551496fc380f1","title":"","text":"This code () Produces ICE on any channel\nThis is the same issue as , attributes on expressions are not converted into HIR properly.\nI checked on latest nightly - isn't produced anymore while this one still throws ICE.\ncould you reopen this issue?\ntriage: P-high. Removing nomination.\nReduced somewhat:"}
{"_id":"doc-en-rust-5923fe45b718fab55ab35d21c8370569fc6087fac5f9f0992fc6d95dce139465","title":"","text":"Ferrocene CI has detected that this test was broken by rust-lang/rust . Specifically, by the change in , shown below: Test output: Reverting that single line diff fixes the test for the QNX7.1 targets, e.g. and can the change be reverted or does QNX7.0 need to use , instead of , here? from looking at libc, it appears that both and are available on QNX7.0 so reverting the change should at least not cause compilation or linking errors. if the case is the latter, then we should use in addition to .\nthanks for the report! I will need to re-test it for QNX 7.0, to see if it is a 7.0 requirement (i don't recall why this was required initially, but clearly I ran into some issues with it). I also plan to do a similar automation to ensure 7.0 builds run without problems on our hardware. Is there a list of tests you see failing on 7.1 that are OK to ignore? I see a list - is this the most relevant one? Thx!\nwe do not ignore any single unit test at the moment and we run library (e.g. libstd) tests as well as (cross) compilation tests using . we don't pass to but instead pass the list of test suites as arguments. we currently run these test suites:\nWG-prioritization assigning priority (). label -I-prioritize +P-low\nfixed in"}
{"_id":"doc-en-rust-de22af721fb25138d2aaed4e7b4c52fba8f41c15dc05846eb12776c09f9007ec","title":"","text":"Found as a byproduct of work on backtrace: Compiles on stable 1.35.0.\ntriage: Looks like matthewjasper is on top of this. Marking P-high just so I don't have to think about it further right now. Removing nomination tag."}
{"_id":"doc-en-rust-a7b87161b4a123f1ea6d71221d60989327d1e8bcd7ca66623c68091caced4908","title":"","text":"Happens on stable 1.34.2, 1.35.0 and current nightly (2019-05-28). . Results in:\nReduced:\nCompiles fine on 1.34.0; haven't tested 1.34.1.\nboth my repro and your reduced one do ICE on (and ) for me, can you verify that again?\nHappens all the way back to 1.30.0 (with ) for me, as long as is passed to rustc.\nAh of course! is needed for NLL on older versions... :) I forgot that godbolt doesn't have that by default."}
{"_id":"doc-en-rust-1cdc2b9a8878bd1803c5d5245aa71b492645c50cb4faf7da5def93238c780635","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 used to work on Rust : is present in the framework (on macOS +10.13; on lower versions, in the framework). The framework uses internally, so the symbol is available through that (I think). Linking like this worked previously, but since Rust it started failing. This 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. --OS: macOS Mojave 10.14.6. : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nSorry if the issue is not very well explained, I'm very inexperienced with how linking works\nThis is affecting  as well from what I can tell.\nThis appears to have regressed via , cc As a temporary workaround, you can try setting the environment variable to something like .\nWith Rust sets to 10.7 for the linker, if not set, to match what we are passing to LLVM. Setting it to 10.8 or above get rids of the linker failure. I will look into this more.\nCan you elaborate on that? Building it locally with worked fine for me on an M1.\nI can confirm that using gets rid of the linker failure in . For , is required. You need to build a binary, so that the linker is actually invoked. Try building an example (e.g. ).\nI can clarify this a little more: If you were building a Rust program for an Apple platform that linked to APIs with availability somewhere between 10.7+ and 12.0+, and you weren't setting your own deployment target, has revealed a bug in your build process. Your binaries were only ever going to run on recent OS releases, but you would have been unaware without testing."}
{"_id":"doc-en-rust-4975613f6e2312c92f3c5a07c5c1cd0e903b5eaf08cd24da30f1c95f52dcbef9","title":"","text":"For coreaudio, if it really requires APIs from 11.0+, that seems a bit recent/limiting for a library that's existed since forever on macOS. If the authors were unaware of this, has revealed that they need to do more work to attain backwards compatibility. There will be more breakage like it, but it is the good kind, because anyone using newer Apple APIs should be aware of their minimum platform requirement, just as Xcode forces you to be.\nHmm, this change had more impact than I thought. to determine which minimum Macos version to pass as part of the target triple to LLVM and to ld via by looking at the various command line options and environment variables that have accumulated over the years. If nothing is specified, it apparently defaults to the minimum of the specified in the SDKROOTs and the host Macos version . I think ideally we should probably try to mimic this behavior somewhat so we don't confront users with having to set , while they don't have to do it using clang. Not sure how we can easily accomplish this though.\nActually, that makes a lot of sense, thanks! I fully agree that it's better to catch these issues when developing (instead of later, when users complain that the application doesn't work on their older system)! I've opened to fix the linking in , and would fix the linking in .\nNote that this is a breaking change for macOS users, before, they didn't have to specify , now they do. Furthermore, they have no easy way to find out that they need to (they just get a confusing linker error)! Additionally, the affected crates (that we know about) are quite widely used (at least half of all Rust games depend on and/or ), and have not yet fixed the issue, nor yet released updated versions which includes these fixes. And even when this has been done, it will take time before users have run and received working versions (can probably be helped along by yanking the affected versions). I don't really know the procedure for this, but I would like to propose reverting (at least from the current beta) to give the affected crates more time to update. Again, I really do agree with the change, I just also want to minimize the breakage macOS users will experience from upgrading Rust."}
{"_id":"doc-en-rust-f8aa393691be1608d72f852726c4c506d1a56b8fdacf00549f4cadb9c11ed57e","title":"","text":"Like I wrote I think ideally we should match clang's behavior and thus fall back to the default of the currently configured Macos SDK. That would mean looking at the property of the in the currently configured SDK. Unfortunately I don't really see a reliable way to do get the path to that without running .\nI think we should revert the change until you find a way to do this - it seems to be causing a lot of breakage and my understanding is the goal was just to turn a runtime error into a link time error.\nOh sure. I am not against a revert until that is sorted out. I will open a PR. claim\nreopening as this is a beta-regression, and we keep those open until beta fix lands (or we explicitly decline to fix).\nBackport merged.\nJust for reference, the linking in the noted crates have since been fixed: , ,\nI root-caused this a little bit more today, sharing my findings: The problem can be reproduced with and the following file: Weirdly enough, if you remove the linking to , everything links fine. I think this is actually a bug in , it seems like: The linker is reading the symbol tables from and to try to figure out where comes from. When reading , it sees that it has a few \"\", which includes , which is where the symbol actually comes from (well, nowadays from , but that is re-exported from ). But when reading , it finds the symbol , which is intended to indicate that \"when linking on older platforms, use instead\" But instead, it ends up making it seem like is actually the real , and does not expose , so the linking fails. Again, I believe this to be a linker bug because the problem does not happen with (try passing )."}
{"_id":"doc-en-rust-5a19f9d590d60df01202720f0e8260d5a9669c8113a21da25106b7198a3705df","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: ().haserrors().issome()'', 'thread 'rustc' panicked at 'assertion failed: ().haserrors().issome()'' 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 --\ncc\nin 'ish ICEs, I am seeing ice now, im wondering if that also relates to somehow :thinking:\nQuite likely, I'll take a look.\nI can reproduce this. It's Saturday morning here, I might get to it today, if not I'll look on Monday morning.\nFixing this is really easy, I just need to adjust the assertion a tiny bit. The hard part is deciding where to put the test. is the obvious place, but then I get complaining that there are too many files in that directory. Suggestions?\njust bump the limit by one like everybody else? :upsidedownface: :seenoevil:\nI ended up putting the test in , because it happens during type checking."}
{"_id":"doc-en-rust-288edc86e71342a0b2dce1b7087b37fc2f3de6005fa8127f5812219868e2e01c","title":"","text":"One of the easiest ways to make CI faster is to make things parallel and simply use the hardware we have available to us. Unfortunately though we don't have a lot of data about how parallel our build is. Are there steps we think are parallel but actually aren't? Are we pegged to one core for long durations when there's other work we could be doing? The general idea here is that we'd spin up a daemon at the very start of the build which would sample CPU utilization every so often. This daemon would then update a file that's either displayed or uploaded at the end of the build. Hopefully we could then use these logs to get a better view into how the builders are working during the build, diagnose non-parallel portions of the build, and implement fixes to use all the cpus we've got. cc\nOn Windows this can be done by taking advantage of job objects. If the entire build is wrapped in a job object then we can call with to get a bunch of useful data.\nI made script that will print output into the travis log every 30 seconds , . Some findings: Cloning submodules jemalloc, libcompilerbuildtins and liblibc alone takes 30 seconds. While building bootstrap, compiling serdederive, serdejson and bootstrap crates seems to take 30 seconds (total build time: 47 seconds). stage0: Compiling tidy crate seems to take around 30 seconds. Compiling rustcerrors takes at least 2 minutes, only one codegen-unit is used Compiling syntaxext takes 9 minutes, only one CGU used stage0 codegen artifacts: Compiling rustcllvm takes 1,5 minutes, one CGU During stage1, rustcerrors and syntaxext builds are approximately as slow as during stage0, rustc_plugins 2 minutes, one CGU. stage2: rustdoc took 2 minutes to build, one CGU compiletest suite=run-make mode=run-make: It looks like there is a single test that takes around 3 minutes to complete and has no parallelization. Testing alloc stage1: building liballoc takes around a minute Testing syntax stage1: building syntax takes 1.5 minutes, one CGU Notes: When the load average dropped towards 1, I assumed only one codegen unit was active."}
{"_id":"doc-en-rust-c9349c8af183942c6625545dd8f3df6d1166269b5984800e8d330c961f81cffb","title":"","text":"The script was only applied to the default pullrequest travis-ci configuration.\nAs shown in , the CPUs assigned to each job may have some performance difference: Intel(R) Xeon(R) CPU E5-2630 v3 @ 2.40GHz Intel(R) Xeon(R) CPU E5-2680 v3 @ 2.50GHz The clock-rate 2.4 GHz vs 2.5 GHz shouldn't make any noticeable difference though (this would at most slow down by 7.2 minutes out of 3 hours if everything is CPU-bound). It is not enough to explain the timeout in .\nI was working on recently for this where it periodically prints out the CPU usage as a percentage for the whole system (aka 1 core on a 4 core machine is 25%). I only got Linux/OSX working though and was unable to figure out a good way to do it on Windows. My thinking for how we'd do this is probably download a binary near the beginning of the build (or set up some script). We'd then run just before we run . That way we could correlate the two timestamps of each log (the main log and the to similar moments in time. Initially I was also thinking we'd just at the end of the build and scrape it later if need be."}
{"_id":"doc-en-rust-f210490f08150d7e55e633bb3845aa2e8dab69ad11ef823a468b77c886a39aea","title":"","text":"Warning:\nBy the way, the warning goes away if you explicitly specify the trait who's static method you are calling, like so:"}
{"_id":"doc-en-rust-03fb3a3ec8d0a6b6be13d715d4a251098021491b1b0471a0716bff968e7f53ff","title":"","text":"Part of Here's what needs to be done to close out this issue: is fine, but should point out why and the primitive type are different. should use the same boilerplate as  has the same issue. has the same issue. has the same issue. should link to the method it comes from. should use the same boilerplate as . should link to those functions. should have an example of implementing it. should link the types it mentions. should link that .\nAs shown in , there's a lot of junk there that could be in instead.\nI am happy to mentor anyone who wants to tackle this issue.\nHello! I'd like to give this issue a try.\nthat'd be great! this issue is very general, so any improvements would be welcome. Let me know if you need any help!\nShouldn't this remain open? 3 points have been hit on, but the rest of the bullets need to be addressed\nYes, whoops! That was an auto-close from a PR message; gotta be careful with that!\nCan you explain what you mean by \"the same boilerplate\" in points 2-5? Boilerplate as in the description text or the struct line, or something else? Getting some clarification could get those knocked out in short order\nYes, absolutely! is the main set of iterators, for . When I did these docs, I took care to make them all consistent: etc. and etc don't use this; when I wrote it, I was thinking that would be the right way to go; but looks like is slightly different than the ones. So we should change all of these to look like the ones in . Make sense?\nAhhh, so for , it should be something along the lines of: An iterator over the lines of a string, as string slices. With the proper links to and as well, yes? I could run through each of those structs, format them like that, with a commit for each and then do one big pull request for the lot of them if that would be convenient\nExactly. Sure thing! That'd be great.\nI think the last two PRs should take care of the remaining bits of the task list. When they're merged, I think we'll be good to close this issue out!"}
{"_id":"doc-en-rust-ec6274dcdb06bd1062a33c5bfedfd7674839d4a5ee0bebe863ad35b832c85378","title":"","text":"Module documentation () Bytes should use the same boilerplate as Lines () CharIndices has the same issue. () Chars has the same issue. () EncodeUtf16 has the same issue. () ParseBoolError should link to the method it comes from. () SplitWhitespace should use the same boilerplate as Lines. () Utf8Error should link to those functions. () FromStr should have an example of implementing it. () fromutf8 should link the types it mentions. () fromutf8_unchecked should link that &str. ()\nEverything's merged! Good to close\nYes! Thank you for all the help!"}
{"_id":"doc-en-rust-5d0d21894cfa4d73f8fee73fe4896e60fefd222c19d3497ab7a41e32fe7c9d19","title":"","text":"Repro steps: create a new cargo binary with . Replace with the following code. Then run . Hope this is helpful! I've tried to minimize the code as much as possible. : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nThe same issue happens in the latest nightly as well.\nThis bisects to nightly-2021-06-25. Commit range: It only reproduces with , not , which means bisecting to the old nightly needs in In that range, looks the most relevant because it is the only thing introducing edition-specific behavior, and it's dealing with closure capture and the presence of a closure appears necessary in the minimal repro. would you be interested in taking a look?\nFor comparison, the same code with doesn't emit a compiler error and has a bit more info:\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-low\nIn both and , function returns value every time but somehow in value unwraps into error, even though it's This is the returned value:\nTriage: This is no longer ICE with the latest nightly, since (presumably ). Marked as ."}
{"_id":"doc-en-rust-489443e5248aa4330b475e59697be80542255803f5e88eb890c8ca775510d093","title":"","text":"Currently there are no landing pads generated for resource destructors so they are leaky when they fail. We don't have the same tricky situation that C++ has with throwing destructors but I haven't thought through how it should work yet. Edit: This issue has changed into what to do after a dtor fails during unwinding. The previous issue of dtor failure not working at all has been resolved.\nThere's a failing test in run-fail/unwind-resource-\nAnd another in run-fail/unwind-resource-\nThe language reference is actually quite explicit about this: \"A task may transition to the failing state at any time, due to an un-trapped signal or the evaluation of a fail expression. Once failing, a task unwinds its stack and transitions to the dead state. Unwinding the stack of a task is done by the task itself, on its own control stack. If a value with a destructor is freed during unwinding, the code for the destructor is run, also on the task's control stack. Running the destructor code causes a temporary transition to a running state, and allows the destructor code to cause any subsequent state transitions. The original task of unwinding and failing thereby may suspend temporarily, and may involve (recursive) unwinding of the stack of a failed destructor. Nonetheless, the outermost unwinding activity will continue until the stack is unwound and the task transitions to the dead state. There is no way to “recover” from task failure. Once a task has temporarily suspended its unwinding in the failing state, failure occurring from within this destructor results in hard failure. The unwinding procedure of hard failure frees resources but does not execute destructors. The original (soft) failure is still resumed at the point where it was temporarily suspended. \"\nYeah. The hard/soft thing has never been implemented, as far as I know, but I think it's the best we can do: retain correctness of our memory model and try to retain correctness of user code, but not at the cost of infinite-recursion. If their dtor itself fails, just unwind that sub-failure w/o the opportunity for sub-sub-failures.\n\bIt would be good to revise the title of this bug to reflect what the task is."}
{"_id":"doc-en-rust-5464ca231507d9568250aeffffbe415e887d3f8141d0c180c284383a6b3c72d1","title":"","text":"(From the comments thus far, it sounds like the task is to implement the hard/sort failure unwindin protocol; but it might also be useful to clean up the docs here.)\nNot critical for 0.6; de-milestoning\nconfirmed again; current code that can crash is as follows: If my idea for an effect system goes through, we might make this sound again by simply requiring no failure in destructors, e.g. .\nnominating for well-defined milestone\nthere is language about this in the manual already in the task section, so I think it's well defined already. just not implemented. feature completeness issue.\naccepted for feature-complete milestone\nTriage: the updated version of example still crashes:\n0 backcompat\nThis not only applies to destructors failing while failing, but this appears to also apply to linked failure as well. A program may only contain one statement, but it may still leak due to linked failure. An example of this would be: The destructor for never runs in this program because the call to invokes scheduler business which will realize that it needs to fail due to linked failure. It seems odd to me that if a task only contains one source of failure then we can still leak. This specific use case may not entirely fall under this issue, but it seems fairly serious.\nThe scheduler does have logic for not failing from linked failure when a task is already failing. So if, for example, the sleeping destructor here were to happen during unwinding, I think it should be fine. But if it happens normally you could still get failure.\nI've updated the title to reflect what we're currently talking about. My understanding is that it is just impossible to throw from a landing pad because it will potentially corrupt the unwinder and our three options are: abort - this is what C++ does resume unwinding without completing the landing pad - this is what Ada does and we haven't discussed this option abort the task without completing unwinding - this is \"hard\" failure we've talked about The \"hard\" failure is made more difficult by tasks that are not simply green threads. For example, we have use cases where we want to run in a 'task context', on the current thread, and then be told whether the task succeeded or failed, all on the same thread. There's no way in that scenario to just terminate the task cleanly."}
{"_id":"doc-en-rust-b972e39146c67c7a29a70e0bc839edd17ee1ecb5027dbba4d6fb43f6c716ab91","title":"","text":"My current opinion is that, for 1.0 we should take the most conservative approach and abort. For future versions we should consider trying to do what Ada does and skip a single landing pad, but still proceed to catch the exception.\nI agree with double-abort for 1.0. Thinking about the other two schemes in terms of how RWARCs (or whatever they're called these days) behave, aborting just a single task strikes me as risky in terms of unexpected behaviour befalling the user. If a double-failure occurs inside an access to a RWARC, it won't be automatically unlocked during unwinding, and other contending tasks will block forever. I think that resuming the unwinding and skipping the one landing pad still makes sense, though. If double-failure occurs in a user-provided destructor (or in the destructor of some buggy library), skipping the rest of the destructor can only \"surprise\" other code directly associated with the faulty destructor.\nI agree too."}
{"_id":"doc-en-rust-0bf145138ec003d839ad09c348b9dfd7e39851c78d1f7bd82ee967a0021119f4","title":"","text":"This is the correct output. Notice that one of the errors has a column of whitespace between the line number and the pipes, the next does not. Commit range:\nMentioning who made changes in librustc_errors. Could this be from ?\nIt looks like this can cause the wrong line number to be printed. :( If you bump the problematic line down to line 100, it prints as 10:\nIt seems like it might be.\nIndeed. Upon closer inspection I've found out that actually changes the semantics of method: after applying this commit, if is not empty, then of them is not compared with , although could actually be greater. The correct code should rather look like this: Although it might be not the bug responsible for this issue, it definetely should be fixed. I'll make a PR with fix ASAP. EDIT:\nSubtle. That seems about right."}
{"_id":"doc-en-rust-140863e760a41f08d661a13a9ac18c21e18ccb20b638824a8ef6d2ffff87960c","title":"","text":"Perhaps there's a minimum amount of debug info we can output by default without breaking things. This is alarming to newcomers.\nI am 99% confident this comes straight from dsymutil.\nPossibly related to\nnon-critical for 0.6, de-milestoning\n+1 to fix this or provide temporary \"fix\"\nAs a new user curious about the language, this definitely made me think I'd done something wrong while building. This issue is also not a top result in Google if you search for the full error message and I haven't seen anywhere else that the issue is detailed. While this is totally understandable in a pre 1.0 release, it would be really nice to have a note that it's expected in the README and/or printed to the console at the end of the build output.\n+1 30 seconds into playing with rust, initial impression: 0.6 is still not ready for anything more than casual experimentation. If that's the message you intend to send, well done!\n+1 Occurs when building rust, and when compiling .rs files. I was almost certain my build had failed since the last ~6 lines were these warnings (while everything was fine). I also get this warning every time I compile any .rs file.\nNominating, production ready.\naccepted for production-ready milestone\nThanks! I know it's a small thing, but I certainly appreciate it :)\nI'd be curious what happens if we stop running dsymutil for non-debug builds. In particular, does the gdb experience suffer at all when debugging the resulting binary?\nI am writing a rustpkg script for to fix cadencemarseille/rust-pcre and this is tripping me up because part of the script looks at output, which includes this warning in the data. For now I think I'll just use the last line of output, but it would be great to have this issue fixed.\nI'm still getting this in Homebrew Rust on Mavericks. Trace: System: When Homebrew gets Rust 0.9 for Mavericks, will this be fixed?\nI get this all the time still.\nThat's probably because we build servo with debug symbols, hence we run dsymutil. I would expect will have a better experience.\nThe job failed! Check out the build log: <details<summary<iClick to see the possible cause of the failure (guessed by this bot)</i</summary</details"}
{"_id":"doc-en-rust-9140f1fce1cfa566cafbbd49ced2504e8f6cc0b8fac605bf6e96be7352413b0b","title":"","text":"This page isn’t working is currently unable to handle this request. HTTP ERROR 503\nThe bot got moved at some point; try Are there some docs that need to be updated?\nOr how about made 302 redirect to the new target url?\nAre there some docs that need to be updated? There are few references to the old address in the rust repo, including (all can be found by searching \"buildbot\").\nFixed the broken link in so I'm going to remove the issue tag here. It would be nice if there was a or something that was a GitHub Pages site that had an for and whatever else relevant resources for maintaining the queue. It'd be easy to change if the homu link changes again in the future.\nI on IRC how to do this awhile ago, and I believe they're still basically applicable today. If anyone would like to help implement this and still has questions please just let me know!"}
{"_id":"doc-en-rust-5db0f739e1d608e1359bcf2428d209445c9811131e415ea1baed828c225412f2","title":"","text":"The full repo is here: : </p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nFor what it's worth, I can reproduce this issue with version 1.63.0, but it doesn't happen with 1.64.0 nor with the latest stable version 1.66.0.\nThe ICE disappeared in nightly-2022-07-01, which contains the following merges: [x] : ICEs [x] : ICEs [x] : ICEs [x] : ICEs [ ] [x] : ICEs\nHere is it minified, and standalone-ed:\nTriage: This has been fixed on the latest nightly, as reported, and needs a test to close.\nclaim"}
{"_id":"doc-en-rust-2df9c554bf581540613b30c7e8304434419559df1aa1e647992513b66edc9565","title":"","text":"This test program should exit quietly, but with , it instead fails the assertion: I also tested a really old 32-bit compiler, and it also failed: This test case is reduced from .\nProbably a dup of (and )\nPerhaps it's a dup. The other two issues are broken with and without optimizations, though. This issue only fails with optimizations.\nAlso: the expression in this issue doesn't actually require any overlap of the match patterns. (I'll update the test case.)\nThe bug also happens without a expression:\nGood point. Also, this only happens with opt-level=2 (not 0 or 3).\ncc Further refinement of the test case: Changing from to a large enough value avoids the bug. Apparently, the value needs to be large enough that, when rounded to the next highest power-of-two-minus-one, it is at least as large as . I think this is an LLVM bug. It involves the metadata. It's as if the compiler is reusing the range information from the check to elide the check (which is missing from the x64 assembly). Relevant unoptimized LLVM IR: isn't used in the test program. When I change its value, the only difference I notice in the unoptimized LLVM IR is in the range metadata (i.e. ).\nThanks Ryan! Indeed LLVM replaces the load with another disregarding the range information.\nPatch is at\nPatch landed upstream.\nUsing yesterday's nightly, fails on at this single test. The problem seems to be local llvm 3.6 is still allowed by the build system."}
{"_id":"doc-en-rust-52873dc2de70d38534dff71082ff73ce7cef1db91c14506d4d76a3938ccd2a5a","title":"","text":"According to my CI this started 2020-04-16 (https://travis-) - : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nreports a regression in (PR ), cc\nAssigning as and removing .\nassign\nOh dear, I was hoping crater will find all such issues (this is ). I guess nobody in the wild is pattern-matching tuples with non-literal-length arrays. I can repro by adding this line () to the test (and the PR fixing this should IMO add the line to ): The fix is likely trivial: add another normalization, like in Presumably, for field accesses, this time (weird that doesn't trigger the bug). <hr/I've brought it up before w/ (but I don't know if I've seen a response), that the lack of normalization for array lengths in typeck is pushing complexity to the rest of the compiler and maybe we should do it in typeck. But then again, Lazy Normalization Is Coming, so maybe there's no point.\nI believe I responded in the PR where you already asked me about that. I'm fine reintroducing a normalization phase"}
{"_id":"doc-en-rust-bf87b42aefc13bfda1b39cac27e454ad05a42c7f50c60a85a1d1b83cfdaf60af","title":"","text":"I am learning rust and reading the book for the first time The section mentions a \"Next Project\" at the very end We can add a link to that project ?\nIt's referring to the next project showed in the book (so next section if I remember well). If confirms, this issue can be closed.\nActually, this sentence is vestigial from when we had the Dining Philosophers chapter. I would actually prefer to remove this sentence. Want to submit another PR? :D\nabsolutely :-) on it\nwas interested in looking at the old . pasted here for future people was removed in\nsent PR"}
{"_id":"doc-en-rust-d9a95d8252b8808ea51e02cfd698cda906e8409d5c2b737572c6edc48b0b589b","title":"","text":"There is no such thing as boxsyntax anymore :D <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\ndoes the same.\nIt probably makes sense to search across the repository (including submodules) any references to this removed feature and remove them\nclaim"}
{"_id":"doc-en-rust-45efef0229c4766ecfdd3173c73ee58d24e7069ec3baffd913c7c9f351d53171","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 currently fails, even though no symlinks are involved. This is because on Unix are currently compared on the totality of their contained unix , which are bitflags of the form (in octal) where is a Unix permission mode and the actual file type. As of now, depending on how the is built, may be either (from ) or set to the actual file permission mode (if built from ). (This bug was co-investigated with <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\nlabel: +T-libs-api + Libs-Small\nError: Parsing relabel command in failed: ...'libs-api +' ' Libs-Smal'... Please file an issue on GitHub at if there's a problem with this bot, or reach out on on Zulip.\nlabel: +T-libs-api +Libs-Small\nError: Label Libs-Small 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.\nlabel: +T-libs-api"}
{"_id":"doc-en-rust-5d43d4b51e473d6b281e1d8ec940587a45f47bfe6076e417a10f9c1d62925477","title":"","text":"() Errors: Backtrace: modify labels: +I-hang +T-compiler +C-bug +A-lifetimes\nsomewhat minimized: To replicate this I needed: async two other arguments by ref at least one arg must not be bound to , compiles quickly the problematic argument must be contain an indirection: compiles fine. and also freeze. and a trait object containing at least one non marker trait explicitly bound to . and are both ok\nrepro is a regression in 1.43. It compiles immediately with 1.39 through 1.42.\nI am currently bisecting this using\nregression in modify labels: -E-needs-bisection\nFYI who had context on ."}
{"_id":"doc-en-rust-57e6292c5d8bb6de10e1ecfd414142df07866cb825105031af45cd9a7f16c9db","title":"","text":"rustc 1.12.0-nightly ( 2016-07-10) Changing the order of bounds in the associated type declaration changes which causes a spurious \"mismatched types\" error. Using UFCS works around the issue: The same issue exists with bounds like to compare with itself as well as another type. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncf.\nLooks like this is caused by on the set of bounds from the trait, but that is just find the first one (in the order they are internally stored), this needs to filter and produce a vector of bounds or something similar. cc\nUpdate: using filter and then calling on all matching bounds does not fix this issue.\nI believe your problem is . Right now it works fine because the above would trigger for vs or vs . However, it's incorrect with your changes as is dropped in favor of even if and are not equal. The correct form would be more like this:\nI guess that you didn't just call , but are also packaging up the specific bound that was matched? Anyway, not having seen the full diff, the general direction of these changes make sense to me.\nRelated:\ntriage: P-medium\nTriage: :\nThis is fixed on current master. Should be closed.\nI would like to work on this issue if its still relevant?\nAs mentioned the original code now compiles: Closing as there doesn’t seem to be anything left to do here.\ndo we have any regression test? I couldn't see any.\nOh good point. Sorry I missed the label. Yes, feel free to work on adding a regression test!\nclaim"}
{"_id":"doc-en-rust-c41efa6acce4e7ec8bfb39cc7fb2535bf145ce5bdbf38b427eff9c3f72ee0d1e","title":"","text":"This is clearly ridiculous, but rustc is perfectly happy with it. Regression from 1.9.\nprints . Using the constant in any other way, e.g. errors out:\ncc is that fallout from your new const eval?\nI haven't removed anything, not that I can think of, to cause this.\nThen it's very likely fallout from (skipping double negations)\nThe remaining error in that testcase feels wrong. should, IMO, be - the literal is in range, but the negation overflows.\nActually I think it should be valid code, but yield , at least that's what the original literal out of range lints do\nBut overflows when negating, which is an error. Why should it be different than ?\nI have no particular opinion on this. But the lint has code handling double negations: (it's treating double negations as if they weren't there at all)\nThe double negation is not the issue here. The value of evaluates to , as expected. But consider the following code: This will also compile just fine and print . It goes wrong in the cast . Rust doesn't check if cast overflows, so the value becomes .  can be changed to disallow casts that fail. (I'd be happy to implement this myself.) Or we can accept that these casts are can overflow silently.\nI believe the issue is that --128 (aka 128) is an intermediate result of the computation that is out of bounds for the i8. EDIT: The issue is about the fact that the compiler doesn't complain.\njup, that was a misunderstanding of some code on my part + the issue that processing HIR works the wrong way around (you start with the outer most expression). Reverting should do the job\nI thought that it was intended that would succesfully evaluate to . (That rustc knows that it's overflowing, but is smart to know that double negation will fix it in the end.) Pretend I said nothing."}
{"_id":"doc-en-rust-0050025081a22f913cc307b1407faf3d0b71f1113df92b81da1c66feb031f188","title":"","text":"This file is only and : , but we should add the other float types to this test. The change should wait for since that changes some of these semantics (this PR is almost merged). There are probably a handful of tests that only check and but could use updates with the new types. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nOkay will do that\nFYI you can comment to assign yourself an issue\nclaim"}
{"_id":"doc-en-rust-f64793285949e06fa320af40588c55d72e9c3a09325e93c79fc772fefb28e22a","title":"","text":"Testcase: I was mostly fooling around trying to see if there was any way I could get rustc to believe that it would always know whether Bears<Twas Drop regardless of T; for the test case, I changed it to Clone and got rid of actually setting the constant to true in the default case, as well as some unsafe keywords, to avoid muddying the waters with Drop's semantics. Note that the array trick for turning a constant into a compile time error comes from , so it's not as contrived as it initially appears. Stacktrace:\nThe test case overflows on ` <details</details\nThe code doesn't produce ICE anymore (tested on ), instead, the following error is produced: ()\nthis no longer crashes , marking as needs-test modify labels: E-needs-test"}
{"_id":"doc-en-rust-c5dbf7516b51b3fa4a40718b99ab8fabf0a7603d27e7b671b56e7a96f282dc61","title":"","text":"In the 2017-12-14 Nightly I've seen a significant (almost 20%) compilation-time increase when I use on my code. And the successive day (2017-12-15) the compilation got a bit slower still and the run-time of the binary also got about 8% slower. The successive days the situation kept going slightly worse. Extracting parts of my code to show compiler/code performance is not easy, so I've composed this benchmark function (that solves an Euler problem. If this code isn't enough I will write other similar benchmarks): <details<summarySource code</summary</detailsCompiled with: host: x86_64-pc-windows-gnu Runtime: 2017-12-13: 0.30 seconds 2017-12-20: 0.53 seconds Asm from the the 2017-12-13 compiler: Asm from the the 2017-12-20 compiler:\nCould someone try to reproduce and bisect this?\ncc I think\nWe shouldn't have such big asm differences between successive nightlies, and I don't see anything suspicious in the middle, so it would be good to try and nail down the commit that made the difference.\nI see a regression with this code (note: this is distinct from ). the bad code accesses the stack pointer (%rsp) You have a fast network connection and know how to use . Could you please do so? You should grep for to tell if the code is bad - the bad code includes the following line:\nI bisected original example, just testing the speed of the executable created by a stage 1 and came upon (PR ) as the culprit: the runtime on my machine is around 0.3 seconds before that commit and around 0.7 seconds after. latest example also has a clear difference. The code before that commit (just disassembling the ): And after:\nThat's unfortunate. cc\ncc\nThanks We're looking into it\njust testing the speed of the executable I am not sure if they share the same cause, first a significant compiler performance decrease using --emit=metadata , then the successive Nightly the decrease of the produced binary performance.\nThey should not. However, quite a few big commits landed in the Dec 14 nightly."}
{"_id":"doc-en-rust-71a34b93847c29253a567b7e18242b14031f3e6c1bb470ef28fd1ab835d6c331","title":"","text":"If you could provide an example that exhibits the slowdown with , that would allow us to fix it (is the Dec 13 nightly faster than the Dec 14 nightly which has the same speed, but worse runtime performance, than the Dec 15 nightly?)\nThe last nightly (2017-12-21) has fixed all three problems. Despite some attempts I failed finding a small amount of code that shows a significant compilation slowdown from 2017-12-14 to 2017-12-20, perhaps it's a more diffuse problem that emerges from compiling my whole big amount of code. I am sorry. I don't fully understand your question, but I try to answer creating a table with some data for some of the last Nightlies: Rustc version --emit=metadata Opt build Binary size Run-time 1.24.0-nightly 2017-12-11 4.32 49.78 12.93 1.24.0-nightly 2017-12-12 4.31 48.50 12.84 1.24.0-nightly 2017-12-13 5.15 50.69 12.86 1.24.0-nightly 2017-12-15 5.33 52.98 14.04 1.24.0-nightly 2017-12-17 5.44 53.31 14.03 1.24.0-nightly 2017-12-20 5.47 54.49 14.14 1.24.0-nightly 2017-12-21 4.28 48.82 12.96 The --emit=metadata is a check time. The Opt build is the compilation time for a well optimized build. The binary size is stripped and in bytes. The times are all in seconds.\nEDIT: told me about , so the range is .... EDIT2: at a quick glance, none of those changes should affect binary size or run time. How many times have you run each of these? How much do they vary?"}
{"_id":"doc-en-rust-76c6f80f0cd754bc3f272d9970b9f00ced35debc6880730135d6a594c9889069","title":"","text":"They should be: rustc 1.24.0-nightly ( 2017-12-20) binary: rustc commit-hash: commit-date: 2017-12-20 host: x8664-pc-windows-gnu release: 1.24.0-nightly LLVM version: 4.0 rustc 1.24.0-nightly ( 2017-12-21) binary: rustc commit-hash: commit-date: 2017-12-21 host: x8664-pc-windows-gnu release: 1.24.0-nightly LLVM version: 4.0 Mixing up things seems quite easy here.\nAh, that's why I asked, so the range is .... Still not seeing anything clearly relevant, but maybe someone else from does?\nThe --emit=metadata times are computed as the minimum of four tries. Their variance is very small (on the order of +-0.05) so I think they are reliable. The binary run-time is the minimum of 5 runs, their variance is higher perhaps because they do some I/O, despite using a SSD, about +-0.12. The compilation is slow so there I've done only one time, so those values are the less reliable, but differences above 1.5 seconds should be reliable.\nFor the compilation time issue, maybe there was a bug in NLL that made it active without it being enabled. For the run-time issue, we need to actually investigate this.\nAs in, investigate the cause of the run-time fluctuations and how it unregressed?\nThis is my good old friend the torpedo. LLVM optimizes into this: This is basically equivalent to this pseudo-Rust code After the \"non-constant-address\" write is generated, LLVM is sunk - LLVM has no way of getting rid of the non constant address, and no way of optimizing accesses to the target with that non-constant address.\nUpstream LLVM (that's the yet-to-be-released LLVM 6) has this patch, which avoids the SimplifyCfg sink problem by not running sinking before inlining I have confirmed that - e.g. this code is optimized correctly with the new Until then, I think representing small enums using a struct (rather than an array) should work around this problem."}
{"_id":"doc-en-rust-743e618636739d75ca6a1770f993451b2f5ec4998638be4931a5b07edd86b4c2","title":"","text":"With the 2017-12-22 Nightly all the problems are back: Rustc version --emit=metadata Opt build Binary size Run-time 1.24.0-nightly 2017-12-22 5.36 53.57 13.96\nCoud you open a PR that turns small unions into LLVM structs (rather than arrays)? That should fix the problem.\nThe binaries generated by the last Nightly (1.24.0-nightly 2017-12-25) is further few percents slower (perhaps because of thinLTO?), the compilation times can't be compared now.\nIs there more stable measure besides compile time / run time? They can be affected too easily by the environment especially when the run time is expected to take less than 1 second. The generated assembly size seems to be a good measure.\nPlease re-test next nightly and reopen if not fixed.\nThe run-time of the binary is now OK. The compilation time with --emit=metadata is still quite large.\nCan you open a separate one for compilation times? Seems to be a separate issue.\n, I've tried here:"}
{"_id":"doc-en-rust-f020239427631201084cbb7329b788b424a92488f42a8225f64d9f726512fac8","title":"","text":"I was looking at the generated asm for to see what happens to the array, and was surprised to see a large function with 5(!) call sites for . The generated code doesn't seem to vary with the number of elements in the array. That got me to compare with the functionally equivalent code: which doesn't yield the same assembly at all. The first difference being that the latter doesn't even store the array (only the strs) while the former does. That got me even further in comparing with equivalent loops, up to the extreme (and stupid): vs. The latter generates the simplest code possible: The former not so much:\nDocumenting my thinking in the hopes that it will be useful, or at least that someone will correct me via Campbell's Law. We know that the ASM outputs are different, so let's go back a few steps until we can find where in the toolchain we want to add our improvement. I compiled this on 1.19 with , but the important thing to note is that while iterany is quite bloated, it looks like the for loop has already been optimized: So is just as trivial in LLVM bytecode as it is in assembler - whatever optimizations we needed to do have already happened. We need to go back farther. . Notice that the tables have turned! is more concise than , so the code we need to add should change the MIR output. Note that . So the problem here seems to be that we aren't inlining before we generate LLVM bytecode. But that answer doesn't satisfy me either, because neither the nor the has any calls to , and in fact . So... one of these things is happening: 're failing to inline , and we haven't noticed because LLVM's been inlining this code for us. LLVM doesn't have as much knowledge as we do, so it can't do as good a job as we theoretically could. 've been looking at unoptimized MIR this whole time. This hypothesis seems to be borne out by the fact that when I rerun rustc without optimizations, I get exactly the same MIR output. But , and ? It's possible that both of these hypotheses are correct; maybe this is unoptimized MIR, because the MIR optimizations are doing absolutely nothing to this file!"}
{"_id":"doc-en-rust-976406cbe00b3d9294b8f3fb8e40906ac4c6144c811c5de0940272aaeebf0061","title":"","text":"I'm still cloning rustc, but once I do I'll comment out the MIR optimizations and see where that gets us.\nWell, I can oblige that in one aspect :) You put far too much hope into MIR optimizations. They do very little right now&mdash;inlining, for example, isn't even enabled by default (only with ). Even in the future, when all the MIR optimizations we've ever wanted are implemented, they will only cover a small subset of what LLVM does (there's no point in duplicating all the work that went into LLVM, and that would be impractical anyway). This code looks sufficiently messy that I don't expect MIR optimizations to ever fully optimize it away. For example, that would probably require loop unrolling, which hasn't ever been proposed AFAIK (and if it was, I'd be skeptical of it). In any case, the more interesting question is why LLVM can't optimize the iterator version as well as the alternative. Whatever goes awry in optimizing this, it happens in one of LLVM's many passes.\nThe LLVM IR you posted is very weird. It has multiple branches on constants, and presumably dead code consequently. There's also several branches on values?!? These should all have been cleaned up. After running it through again, I get this IR (names are all messed up cause I did it on , which insists on applying C++ name demangling): <details</detailsThat's... less code, but still very stupid. Why are the adjacent loads and stores not folded away?! A third pass (just at this point) gets rid of them, constant folds the rest, and winds up with . Looks like a nasty phase ordering issue. But what about this IR confuses LLVM so much?\nNeat discovery. Should we move this discussion to LLVM's bug tracker and close this task, then?\nNot necessarily, no. In the past people have tweaked the definitions of iterator methods to help the optimizer. rustc might also be able to help by changing the pass pipeline or by generating better/different IR in the first place.\nThis did optimize out in LLVM 3.9, and was broken by LLVM 4.0."}
{"_id":"doc-en-rust-24aac01a907939aeafe1226089a1532310b5af4cc1e0f9a74499351cbc1464b3","title":"","text":"In more detail, LLVM 3.9 generates the following small code for ( metadata stripped - it doesn't matter, with this function substituted in both 3.9 and 4.0 manage to optimize everything out): While LLVM 4.0 manages to screw up and generate this monstrosity: I think the somehow prevents SROA.\nGoing closer to the root: LLVM 3.9 optimizes the closure in to this: While LLVM 4.0 for some reason generates this:\ncaused by\nThe initial nonequivalence in the filing of the bug report is due to the slice iterator's explicit manual unrolling by 4 in its implementation of any. That might seem bad but as soon as llvm learns to loop optimize a loop with two exits (either the element was found or the iterator reached the end), the explicit unrolling can be removed.\nis the PR that fixed this intended to be a permanent solution, or is it just a workaround? IOW, should we open a new bug to track reevaluating this fix when LLVM is resolved?\nHmmm, mentioned this bug, but you're right, this is older so me \"fixing it\" is probably more coincidental than anything else.\nThat LLVM bug is now tracked at and appears to have had no motion on it in the past 5 years. Assembly in the initial comparison cases remains identical per No other changes, as far as I can tell.\nThis was nominally resolved on our end, but was left open in the possibility that the LLVM issue was going to be resolved, so as to remove the \"temporary\" workaround. However, if we wish to track LLVM-side bugs that are not currently an impact on us, but may allow upgrades later, then I believe we may wish to consider tracking them in another form than an issue on the GH tracker, as they are \"not an issue\", so to speak. Alternatively, if we want to track them on this tracker, we may wish to track them in a more organized fashion (e.g. a metabug). I am going to close this issue. Do feel free to reopen this if it regresses again, or it becomes otherwise currently actionable, or if there is a particular reason we must have an open issue on our end to track this LLVM issue for potential improvements as opposed to any of the other currently-open LLVM issues we could be potentially waiting on in order to make an improvement."}
{"_id":"doc-en-rust-766e293c61eaaa855df526f09483bc4da2ecbf0ebea74614fda27bb69f530343","title":"","text":"The LLVM issue has long since been fixed, so it's possible that the workaround may be removed.\nI think any workarounds here are long gone, since moved to internal iteration way back in"}
{"_id":"doc-en-rust-3998b0fbbd812688a7ae25ca2bc53324b97397a63353e3872c34f27bda93c85f","title":"","text":"This ensures that someone looking at the documentation who searches for the word \"length\" to find the method which returns the length of the method will be able to find the method, and also explains the origin of the name if someone is unaware. I bring this up because one of my coworkers came to me asking for the name of the method, because they were having trouble finding it in the documentation.\nThe problem with this is that it's generally bad to include this in the summary, as it's just repeating what's already been said. So I didn't do this on purpose. I'm not sure what exact text rustdoc searches though.... i'd be against putting this in the summary, but for putting it in the longer description\nWe seem to be very inconsistent about what summaries to use for methods: Some say \"length\" and some say \"number of elements\". Perhaps changing them all to say something like \"Returns the number of elements in / length of the slice.\" would help here.\nIt doesn't need to be in the summary(?), it can be in the body of the doc. already finds and and so on, so the focus is simply in Ctrl+F search inside the doc page itself (if I understand correctly?)."}
{"_id":"doc-en-rust-72f0f3b5408c33a22719773a2806572e906cb640818c4bb0d93411e1017517a8","title":"","text":"This is unfortunate because: gives the impression that documentation fixes should not be submitted here, or are not welcome. prevents you from gathering commonly requested information (link to docs, rust version number, suggested fixes) in an automatic fashion. prevents automatic labelling for documentation-relevant issues. To fix this, . <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nlabel A-meta\nclaim"}
{"_id":"doc-en-rust-7b6d0fb57c58b55783a4b9fde5fc61c55b3714cb1ed6ddb219a40dc9095cec8d","title":"","text":"Run with this in : and inspect . There is an item for the of the blanket impl  and it's default value is . There is an item but the default value is missing. It looks like this: When using instead of the information about the default value is present. It looks like this: This change, which in practice is a regression, is caused by But we can't revert it of course because that will result in ICEs which is even worse. So we need some kind of follow-up fix. labels +A-rustdoc-json +T-rustdoc +C-bug +requires-nightly\nIt seems like you already suggested a fix. Want to open a PR for it?\nYep I will do that as soon as I get time. Probably today.\nIt's not in a hurry. Don't hesitate to ask if you need help."}
{"_id":"doc-en-rust-90ad26c332b91a9df060f40cf076b82572466218dcdc3b4e37b645ed19a0c64f","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.\nThis test is failing:\nmight give a hint what needs to be updated. I haven't gotten a chance to look closely yet.\nYeah, we'll need to emulate that new static thing by Unfortunately I don't entirely understand the static magic that goes on there... there's just a fn ptr stored in a particular section and somehow that is enough?!?\nYes, all platforms have sections that they treat as an array of pointers, filling the entire section, which makes it easy to append more entries, as linkers will happily concatenate sections with the same name. This is how C++ global constructors are implemented everywhere. So I guess there's two levels to this: miri should collect the platform-specific global ctors/dtors (on Linux I think there's also init/fini which work similarly) and execute them before C main (and after, in the case of dtors) when is , the ctors (or just the init flavor?) can also take 1, 2 or 3 arguments, not only 0 arguments (I believe this is also how C main technically works)\nOkay. This is basically I hoped we'd never have to do this... For dtors, we already run TLS dtors, but those are entirely separate (we hook the pthread calls where dtors are set, and then run those functions later). There's no way those can be unified to one mechanism, is there? Also, this begs the question in which order stuff is called before/after main.\nC++ asks itself the same question and I personally haven't heard of there being an answer. The safe thing to do is to make sure any order is safe (in Rust you have to initialize global state before any runtime initialization, so it's safer than C++ where before the constructor runs, the fields are uninitialized). The implementations just go through the sections in order, so the unknown quantity is what order the linker concatenates all of these sections."}
{"_id":"doc-en-rust-c465dcd08362a054ec4e9f0e4e66c2fef7f5aa1f4ca2f98f3ebc241dc4723c6d","title":"","text":"In miri you don't have the linker to think about, but you do need a mechanisms to access all statics from all crates.\nWait, why can't libstd initialize the args from the start lang item as well? Surely there's an inexpensive way to do so?\nThat's what I did originally, but said not to.\nReverting should fix this.\nWe could either adjust the 's to no use the new method when is set, or we could implement those initializers. Seems like we'll want them eventually anyway... What would be the best way to do that?\nIn the short term, excluding from the new mechanism seems like a reasonable solution to unbreak miri. That depends on two factors: what order functions get placed into the sections, and what order they get called. The default linker scripts will collect all sections in sorted order, followed by the section itself, into a single section. Likewise for and . The sort order here uses the linker's , which takes a numeric section suffix as a numeric priority, and sorts sections with non-numeric suffixes asciibetically. (There are also a couple of special cases to make sure that glibc can guarantee its own functions run first/last in a couple of those. And there are some very careful special cases to handle the old , , , and sections, which get translated into corresponding , , , and sections respectively in the final binary to preserve the behavior of those sections, keeping in mind that ctors sections get run in reverse order and the dtors sections get run in forwards order. translates the priority in numbered ctors and dtors sections by subtracting it from .) When loading a program or library, glibc calls the function pointers in in order, then the (single) function (which executes the contents of the section), then the function pointers in in order. At shutdown, glibc calls the function pointers in in reverse order, then the (single) function (which executes the contents of the section). Does that help?\nIt is a great reference, thanks! So far I have no idea how to wire up all these sections in Miri, but I guess we'll see about that. ;) On a separate note, also broke Miri by removing the getter from . I am not sure yet if there is a replacement that we can use instead."}
{"_id":"doc-en-rust-4ca8cfc853f31c6b7433581c330725545d6473e0b032032305cffd37c9872e84","title":"","text":"Leaving that here just so that I hopefully can find it later.\nI don't see any way to actually do that.\nI would prefer to avoid duplicate initialization of arguments. I'd like to make Rust executables smaller, not larger.\nI agree, I would accept this change.\nI opened a PR for that:\nDone. I set it to close this issue since we already have to track the more elaborate approach.\nWell, actually closing the issue will require also bumping the submodule to include\nI don't understand, this would only be a few bytes with ? To unbreak miri it's probably fine but I'm increasingly worried about , as it allows divergence to exist in ways which are not controlled within miri itself.\nI was talking about a user of these facilities, not miri implementation. To expand a bit (although it's kind of offtopic): Rust forces you to mutate a that started out with a constant value (e.g. ), which means nothing else would observe an uninitialized value, just the initial constant value, if it happened to ran before the runtime initialization (which would e.g. replace the with a ). This makes Rust + safer in general than C++ with global constructors.\nAck.\nAand now we also need to wait for to land. That's the third independent Miri-breaking PR in 24h, impressive. ;)"}
{"_id":"doc-en-rust-6f0388cd8ba60402cc5b591aa3bdae6e7d60cf5935d68de4d64c660e4a938289","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.\nUpstream fix has landed:"}
{"_id":"doc-en-rust-4ba4016c415c1575c07d2ee0b6ab9be28620aa99d91eb8e92280f6a4c3cb941b","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</detailsAdding an suffix fixes the issue: The error first appears with the toolchain. It works fine with .\nThe offset intrinsic does not support doing this, it requires isize or usize. ICEs using intrinsics wrongly are expected and not a bug. Thanks for the report anyways.\nShouldn't a occur for the argument?\nThere is nothing to be coerced to, since the intrinsics accept any type on the type level.\nIs this specific to the intrinsic? I tried a couple of other intrinsics, and the compiler complained about mismatched types: : : Doing the same for results in an ICE, e.g.:\nthe intrinsic is generic, that's why it passes type checking\nIt's only generic in the first parameter. And has the exact same signature, but the issue doesn't occur for it.\nHi what is the motivation to keep this check as an ICE instead of a user friendly error since the error arises from misusage of the API?\nGiving better errors for intrinsics and other internal-only features increases maintenance burden, so decided to not support it. Invalid usage of intrinsics may lead to ICEs (since intrinsics should not be used - I see for your case here it makes sense to use them in the tests, but I think you can live with ICEs). I guess it's not ideal that the ICE message says to report it - but fixing that is hard."}
{"_id":"doc-en-rust-2bb8466434f7d52f97104b796741ee6e73fbef6136e0a2e87f1a3560a6f596c1","title":"","text":"The Any trait is not in release condition at all, considering that is still uses slow virtual calls that could be replaced with an associated static in the near future but stabilizing with would mean that it could not be removed. Normally, this isn't an issue, but since Any is almost exclusively used through trait objects this blocks possible optimizations to layout that could allow to be represented as instead of containing a full vtable.\nIt would need to be , where the is the destructor (btw)."}
{"_id":"doc-en-rust-069405b501f0e546f28d9b10d313572e89188902e86e202852d11618e1634404","title":"","text":"From : It's easy, according to implement my own ` implementation for free. In retrospect it makes sense, but it was not obvious to me at all just from reading the docs. It is not mentioned in , or the docs for . And as the link in my post suggests, trying to work my way around the ownership of the APIs led me quite far afield. Admittedly it's not the most common case, but I think it would save others time if the standard library at least mentioned this somewhere. EDIT: fixed forum link which changed its name when I marked it solved.\nA section about \"you should consider overloading these things\" definitely sounds good. should also be on that list. (In the future or in nightly is in that list too, .)\nYour forum link is broken.\nThe docs do say However, I do like 's suggestion, about talking about which methods you may want to override.\nSuch hints should be non-normative though to allow the implementations, especially specializations, to use different approaches in the future.\nAgreed, I was picturing more which methods to consider overloading, not specifically which things use them. (Or, contrapositively, which things there's usually no reason to overload, like , because the default implementation is generally as good as it gets because it's a trivial wrapper.)\nSo basically this issue is about adding some documentation on which methods you might want to override right? Which methods do you think are best to mention? Or did I misinterpret the discussion?\nThat's correctly, probably under or near For now my inclination would be to mention and -- once stable it should be instead, but IIRC we don't mention unstable in the broader docs until it stabilizes.\nWhat about adding this line of text at the end of the \"Implementing Iterator\" section? which call internally. However, it is also possible to write a custom implementation of methods such as and if an iterator is able to compute them more efficiently without calling . Feel free to adjust the text or make something up yourself :) If you agree I will create a PR for this.\nI think it would also be nice to add something to the documentation. How about this? Rather than overriding this method directly, instead override the method.\nin case it wasn't clear or you are not watching your GitHub notifications, I approve of both your and suggestions. I look forward to the PR!"}
{"_id":"doc-en-rust-f68ea4b7b2d5dd8af323f213ecffdfd834d941669927fc9ddebbe652dbea89de","title":"","text":"Sorry for the late reply! I apparently don't get notifications for thumbs ups and the like! I will hopefully be able to create a PR somewhere this midday."}
{"_id":"doc-en-rust-ffebb65bb64f23bd970ab7fdedc232cdf22dae29ceb2647419a7429c1ade41ed","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 don't have a minimal example yet, but here's . Sample: The ICE happens on the and macros, which are both from the crate. <!-- If 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 began with commit . <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nFYI, I think that link is only accessible to Googlers: !\nSorry, .\nMinimized: Caused by\nWhen we run on the AST, we create a definition for the desugared closure body inside an : As a result, the entry for our macro call will have the of the desugared closure. However, this desugared closure does not actually exist in the AST (it is created during lowering), so we will never check for lints with its when we emit buffered early lints.\nNightly has been broken for 3 days, if there's disagreement on how to fix the issue, can we revert while the fix is being worked on?\nThis will be fixed by PR\nI'm still hitting this bug with the latest nightly."}
{"_id":"doc-en-rust-d3b602b17dd50e2c961434156a5bc8e31eb7d887911b3e9a492b6b409c408466","title":"","text":"The following function can drop any object arbitrary number of times, using only safe code: Probably bad :) Found while researching\nNominating for P-high\ncc\nToo bad this doesn't just cancel out the Leakocalypse :stuckouttongue:\n(well, any object that implements . But yes, I see the point being made here.)\nlook, no required. I guess it doesn't work for types that are already unsized.\nto be clear, I am looking at this now as well. :)\nI guess is related.\nI hope it is unrelated. In particular I wrote this on that ticket:\nYeah, it's unrelated. The call happens for , which does need drop."}
{"_id":"doc-en-rust-9f98c89c0a2b19b83710cee03ec8ae17fab97310d761740e51206f9ab301fe20","title":"","text":"From: src/test/compile- Error E0124 needs a spanlabel and a spannote replaced with a span_label, updating it from: To:\nError message updated in ."}
{"_id":"doc-en-rust-4dec27bc912d0753e99a53a9c9ae225add7cc8203bfe3a2ff53a5df80778090f","title":"","text":"Looking at without prior knowledge of Windows system call semantics, I see an infinite loop if the syscall were to fill up the buffer exactly: when k == n on line 195, the loop will be rerun with no changes, which should result in the exact same outcome if the syscall is idempotent. Even if Windows guarantees in some way that this cannot happen, would it not be clearer to handle this case in an obvious fashion?\nHere's one of the docs on how usually works in Win32: Note the difference in lengths between success and failure. So there's two potential cases where : Success: If the buffer size (with NULL) were to be equal to the successfully copied size (without NULL) then the buffer would be too small to hold the full string (NULL included). So this can't happen. Failure: If the buffer size (with NULL) were to be equal to the buffer size needed (with NULL) then the string would have been successfully copied into the buffer. So this can't happen. So Windows does indeed guarantee this can't happen.\nOTOH on some versions returns the size written including the NUL terminator, so for that function the infinite loop could happen, right? The doubling logic that checks for the insufficient buffer error code must be there for some other function that I have not yet found, it would be great to have a comment as to where this behavior is needed.\nAs far as I know Rust only ever uses the Unicode version of functions (they end in ) and never the \"ANSI\" ones (they end in ). The functions are more consistent across Windows versions. I'm not at all against adding a comment (and returning an error?) in this case but it's not something that should ever happen with the kinds of APIs Rust uses.\nCome to think of it pretty much implies using the functions. It uses a buffer, where as the functions use a buffer. Using this function with the functions would be very broken.\nStill, it would be more robust to change the into , so treat this presumed impossible case as success (absent other evidence) rather than looping.\nMy issue with assuming success is that we can't know what a hypothetical Win32 function is doing in this case. For example, it may have truncated the output or it may even be returning an error code, not a size. We can only guess. Best case is we guess right and it works."}
{"_id":"doc-en-rust-613894f919c4206828f88444df4dcb3ecb55770d29c5651a29c3d3246393e490","title":"","text":"Worse case is we guess wrong and it causes a bug that only becomes apparent later on, making the source of the bug hard to track down. Having given more thought to this, I'm leaning towards using . That would clearly document that the case is thought impossible, while also causing a panic if the function is misused. It might also be good to clearly document the expected return for the function being passed in. E.g.: On success returns the size of the copied string excluding the terminating null. On error returns zero unless the last-error code is set to . If the last-error code is returns the buffer size required, including space for a terminating null.\nYes, that sounds like a good improvement! Since this Win32 behavior is not generically documented, it might also be good to note the exact syscalls that this function has been tested with. I should probably mention that I don’t have a Windows system to develop or test this on, I was merely perusing the code out of curiosity — otherwise I’d volunteer a PR."}
{"_id":"doc-en-rust-cb99e41e3bac24f2f688db0a04a7d6eb7ec5b55a9d3d2599471e14a7eb2164f9","title":"","text":"upstream/master:\nDoes that build include the fix in\nYes, include. 6:45 \"Huon Wilson\" notifications\nThanks for confirming. cc\nReproduced on revision . Note that I'm using win 8.1 with non-english locale which probably causes issues. Quick investigation: then convert the code into string. It seems that failed with .\nSo the issue is broken into two parts: 1. why rustdoc failed and called ? 2. why failed?"}
{"_id":"doc-en-rust-863bba54f7a41ac696146c740900e5f4a220ca115d49a9429bf54c1698b41480","title":"","text":"When compiling a personal project, I got an error that the compiler panicked and entered unreachable code. I've dumped the output: And I committed my code which caused the bug here: It might be because I had only written half of an anonymous function at at line 92. This is not that urgent as I only saw it with half-written code, but since the compiler suggested I file a bug I did. :\nGood call! Reducing it to is enough to trigger the ICE. <details<summarybacktrace </summary\nmodify labels: I-ICE T-compiler C-bug A-frontend\nI've traced the problem down to this call:\ntriage: P-high, removing nomination label."}
{"_id":"doc-en-rust-f2f6b64cfea40bc2447fbbc54e79f48a1a4812bc451005079c243834c8bd66f1","title":"","text":"[][zip] says: However, it is not always true; it actually returns after when the source iterator is not fused. [Playground] [zip]: [Playground]:"}
{"_id":"doc-en-rust-716c667d37bfc93d23e37b447997ed71f2c4a8c469bd6fe4500a20ad9a77a265","title":"","text":"has made it impossible to import some structures in when implementing dataflow analyses in external tools. When implementing for a custom dataflow problem, we can no longer import the or direction. is the source code of such an implementation. is needed to set the type of the trait. Previously, it under the export, but for now it is . The default implementation of the , so I can simply use the default value as a workaround. However, if I need to write a backward analysis, I must rewrite some parts of the framework in our source code because they cannot be imported. There are other tools in the ecosystem that use that API, e.g.: These changes will make problems if they decide to update to the recent toolchain. Could you please take a look at this matter? Are these changes intentional? Could we make some of the exports public again? cc\nFeel free to send in a PR to make it public again. Please add a comment on the items saying they're used by external tools.\nI will double-check which of the removed imports might be beneficial for external tools and will send a PR if there are no objections."}
{"_id":"doc-en-rust-4d1dc482a543fea56e62522e8dbaa5c60da15d3c2b4b9638fae0c21a7f69e3da","title":"","text":"This is a tracking issue for reverting the change introduced in which disabled the toolstate check for the edition-guide. It is currently blocked on which is causing a test failure in the edition-guide. I will reinstate the check as soon as that issue is fixed. has requested the labels t-release and I-nominated.\nTags are so that we don't forget this, we should keep it nominated until it's fixed.\nThe check was reinstated in PR\nI think you have the wrong issue? There were two things (rls and edition guide). The PR you noted just reverted the RLS change. The edition-guide was separate (and done in a different way). It's still blocked on .\n, that's what happen when I read just half of the title :sweat_smile:\ntriage: P-high. Assigning to self. Will likewise triage . Removing nominated tag.\nactually I'll leave nominated tag, since this is for a team other than T-compiler so I don't want to mess with their tags."}
{"_id":"doc-en-rust-0de5c0ef95d026d425457605a1d71acf7f1cf2ec7cacd4ec9591fbb9dd15c184","title":"","text":"(allowing specifying code models was to rustc in ) I want to build a large code model binary. But (correct me if I'm wrong) I believe this requires all code to be generated with a large code model (otherwise we could end up with rip relative addressing in the stdlib, which defeats the point). So I tried the obvious (controlling it with ) and got the following build log: Brief explanation of the three parts: command is run tail end of the stage1 stdlib and rustc itself being built by stage0 tail end of the stage1 stdlib and rustc itself being copied out of the stage0 build directory and into the stage1 directory, then the new stage1 rustc attempting to build the first part of the stage2 stdlib (libcore) segfaulting In fact, this stage1 rustc segfaults when not doing much: Reducing the command line used to build rustc: GDB gives the backtrace as I've dumped a bunch of info in the hope that someone might be able to lend a hand, but I can find little discussion of this feature (code models) so they may not be well-tested? I plan to investigate myself, but wanted a) to see if anyone has any pointers and b) make this a searchable issue. As a datapoint, note that redox uses a .json target specification and with , which obviously works fine. Altering the configure+make command I used to use the kernel model rather than large also worked fine. So it looks like the issue is with memory model large.\nCompiling statically (with glibc, as described at ) makes it not segfault, which is interesting. Doing --enable-debug in configure also makes it not segfault. I starting to suspect the issue is in llvm (I don't think anything in the rust compiler itself generates asm?) and rust tickles the bug somehow.\nRecompiling just the libstd crate without optimisations makes it work. It appears that start , which attempts to calls . calls on linux. By inspection of the parameters passed to in the linux implementation of with gdb, the parameter is an invalid pointer (checked by inspecting by ). In theory should be in steps 2 and 3, though the functions look like they've all been inlined."}
{"_id":"doc-en-rust-bf0c5f86bed3bd124e08bc530d1289d2c371ecd72e36d206ff622b5dfa7accdb","title":"","text":"Managed to tear down std to get this test case: (it seems that since I originally reported this issue, the nightlies now have llvm assertions enabled)\nAbort seems to be coming from TwoAddressInstructionPass. Backtrace (from gdb) at the point of abort is: <details<summaryClick to expand backtrace</summary<p</p</details\nThe rust code two comments up () when compiled with will produce . Inspecting with llvm-dis: If you now try and compile this with you will hit the assertion (assuming your llvm has assertions enabled): It works fine on the latest LLVM head. Turns out the fix was merged december 7th - is the bug, is the fix.\nLooking at the llvm 4 release branch on the llvm-mirror github, this will be fixed when rust upgrades -\nI backported the referenced patch, built a debug rust with it (i.e. debug-rust-large-fixed) and then built a release mode rust also with the backported patch and debug-rust-large-fixed (which took forever) and successfully ended up with a release-rust-large-fixed which can build itself.\nPresumably fixed by LLVM backport -- doesn't reproduce today. I'm marking as E-needstest since it seems like something we should track in tests.\nfwiw this is tricky to do a test for unless we want to do yet another rustc build in CI. I'm going to be rebasing our Rust fork 'shortly' and was planning to just close this issue once that's done and I've verified everything is working.\nOh... do we need to rebuild rustc for it? I was under the impression that just was enough to test. That's all I did...\nUrgh yes. Sorry, this issue has a lot of history for me and I'd forgotten parts of it. Running the testcase above is indeed a valid test of the issue :)\nTriage: apparently a test, but it was removed before it was merged."}
{"_id":"doc-en-rust-28bc25e13a06658183b765e98e89296c58c558e0ebd0d32c11bcfcd0119bc392","title":"","text":"The logging section of the 0.6 docs ( ) doesn't specify how you log messages. This link is broken: It is not broken in the 0.5 docs, but I believe the API has changed."}
{"_id":"doc-en-rust-96296aff305fae824829cbb032768e4b2f7ab1a533f4989f05cc92567a20d173","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: code compiles in a reasonable amount of times or the slice gets elided entirely. Instead, this happened: code takes multiple minutes to compile/gets killed by the playground. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: Also tested on playground stable and nightly.\nThe code compiled in about 6 seconds in Rust 1.29 and 1.30 : . Before that it had capacity error. After that it exceeded 15 seconds limit of godbolt. This is a but I cannot tag it.\nIt looks like this also works correctly on 1.31 stable as well:\nDecided on as in the prioritization working group procedure.\nCc\nFixed in ."}
{"_id":"doc-en-rust-02a7b28e8c04b401cc1b4b964192dc76569ee3ce2be8257050f62fcea8cacc40","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 <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nI think this is the code crashing: Assigning P-low by the same rationale as , but I expect this to be much easier to fix than , , or\nNo longer crashing: `"}
{"_id":"doc-en-rust-66729f3fbcedd68cc9c3f446ce266647eff37d6a2c0662f7093c991d2d34aa6e","title":"","text":"With extra verbose flag (), one would see a lots of warnings about check-cfg when building -Zbuild-std. But it doesn't need to be that way. Can we doodfooding check-cfg flag to and to resolve them? Step to reproduce: I expected to see this happen: No warnings about \" unexpected \" Some are: label +F-check-cfg +-Zbuild-std cc"}
{"_id":"doc-en-rust-a49a60d983ca263c6df1f1b675bee487e19954dff841c117235ecac4d35e3050","title":"","text":"I found an error message that seems a bit off to me. The code: Clearly it should fail to compile, and it does. But the error message is: I would expect something like \"a module name has already been imported\", instead. Is it accurate to call it a type?"}
{"_id":"doc-en-rust-39e2d687634f8d162502f6a0318636a10ce31104b4ce31ac34ed4f52acf989fd","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: (at ) windows-gnu nightly: wasm target: the package for : Result: The invokes . depends on that is not present in the distribution. If I add it manually, the issue goes away. The flavor ships with that does not have this dependency. and (and likely everything between)\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-low +T-compiler +O-windows Edit: my assessment was wrong, this requires more prompt attention label -P-low +P-high\nI have the same issue with \"stable\" rust 1.52.1 ( 2021-05-09) on Windows 10 with a wasm32-unknown-unknown target. Can you elaborate on how to quick-fix this by adding manually? Where can I get, and where do I put I only have from Mingw64, Mingw32, and many other SW packages. Is it the same? Btw. what hit me instantly is the move from LLVM 11 to 12. Might that be the issue?\nYes, at least enough so it works for me. Just rename any zlib binary, the library interface has been stable for a very long time, so it should just work. Or, if you are ok with using binaries received from strangers, take this: . When you have , you need to make it visible. Either place it in any location visible in environment variable, or place it next to the . For me it is located in . See if you want in-depth explanation where the Windows looks for the DLLs.\nIt works, thanks a lot. It was a bit confusing that I don't have rust-lld in the wasm target folder. Now I can work on my fullstack project again without worrying about OS specific issues :-)"}
{"_id":"doc-en-rust-a2b2e3a865b398c33d003cb63cf38758e974b2740eb39e81311ae3cff17c2b32","title":"","text":"this is my attempt to bootstrap rust-1.75.0 beta, which fails with this beauty: this is my command: I can workaround this by reverting can you please have a look at this error and the backtrace? I don't get why this error comes up. Thanks\nthis is my\nThe fixme here seems to be the issue: As workaround you can try to run before the build. cc\nI'm compiling offline, from the beta src tarball.\nI'm aware. It seems that there is a bug when using vendored sources in combination with remap-debuginfo. Creating the directory should help even if it is kept empty.\nWG-prioritization assigning priority (). label -I-prioritize +P-medium\nWell, the cargo eclass is already exporting CARGOHOME env var, and a CARGOREGISTRY_DIR as well, and I'm doubtfull about the package manager allowing x.py to escape it's sandbox. Neverthelss, I'll try your suggestion when I'm back home on the machine.\nIf you have set the directory you need to create is .\nfor your information only"}
{"_id":"doc-en-rust-e4b0e2bb40214946207efb9bd8e9897ea50a15025dc8691e4d120470b3c7f4a0","title":"","text":"Tagging as E-easy and E-mentor. The fix here involves changing the code to call to prevent the temp dir from destroying itself. This should be wrapped in an if like this one:\nHi, I want to try working on this.\nGo ahead! Let me know if you need any assistance - feel free to either reach out here or over IRC (simulacrum is my handle there)."}
{"_id":"doc-en-rust-8001657e7cfe3991a0e31abfbdd568df54d28d4abce1fb86fb56b15072b47766","title":"","text":"From . This means we do not blanket turn on LLVM assertions on all of our bots, which we would ideally like to do. I'm going to try turning them off for just the cross bot though.\ncc cc\nSeems related to somewhat. We do not use the maxnum intrinsic (totally should!) but from the existence of bug for maxnum seems to suggest that a similar issue for some non-maxnum intrinsic is likely to exist (and libcore is kinda intrinsic-heavy)."}
{"_id":"doc-en-rust-268daca50ce956852981f01701d4faa6e6ddc8fed00a3d27b721f37c53f18ef1","title":"","text":"Case sensitivity is a property of the filesystem, not operating system and these functions are filesystem agnostic. As thus, this issue is not actionable. Closing. If you feel differently please complain and I’ll reopen.\nIt's fine if the functions want to be case-sensitive, but their docs need to be changed to point this out explicitly and noticeably. Every Windows user is going to assume that the functions are case-insensitive just like they are in other languages on the platform. (I imagine OSX users will have the same expectation?) It's made slightly worse because is handled in a special way that makes evaluate to despite the mismatched case. So someone using that as a quick test of their assumption would end up with the wrong idea. Would you mind reopening for this reason?\nI think it would also be good to have a crate like provide a that does hit the filesystem. Such an API would also be able to detect when the same folder is specified but using alternate prefixes or mount points or through symbolic links.\nThe driver letter is a symlink in the Object Manager and lookup is always case-insensitive. Folders are located on the filesystem and may or may not be case sensitive. I do think platform specific behaviour should be documented if it can be a source of confusion."}
{"_id":"doc-en-rust-a0cd12642d5d6cdd16c9392a149cdf7b6bde4f3a5ac254b9e697be0e5732a5d0","title":"","text":"Trying to package rust 1.2 into Debian & Ubuntu, I get the following test failures: I am using Debian LLVM 3.6.1 packages (version 3.6.1-1)\nis in the package. I wonder whether we want a check in that makes a requirement or one that disables the respective tests if it is not available.\nThat was indeed the issue. I installed it and I have issue now.\nAddressed in\nThese test should be optional until LLVM has a way to install FileCheck"}
{"_id":"doc-en-rust-5877919613eed86bc13cf4acd9c427ba8662118acbc0c074f15843db2170a128","title":"","text":"The build system that we just turned on is not actually in the source code. cc\nThis is on beta and nightly too.\nReeopening until the backport is fixed because I'm putting this on the release milestone.\nBackported in as"}
{"_id":"doc-en-rust-34b780a1b14e39617347041ac72c9679fc811faf8ea9e2cb967ca1bc94b50f2f","title":"","text":"I tried to get a minimal example, now i just ended up with completely senseless code, that still gives the error. playpen says: if you remove the for loop, only the last two cat_expr notes are left. adding more code just ends up with more of the notes.\nthis is pretty much my fault. :) In all the cases that I have seen where it arises, it is due to a type error (or a type inference failure at at least) somewhere in the code. Of course the notes are incredibly annoying. I will try to fix.\nAnd of course the concrete example given here is one where there is no type error. At least, not one exposed by compiling this code. (I have not yet managed to show being instantiated concretely without causing some other type error to arise.)\n(but there may be a mix of bugs causing the original input here to pass. In particular, the code in the description is doing , but that associated type does not exist. One needs . See also: )\ncc"}
{"_id":"doc-en-rust-064e596224ab8b033dcbde195a3c23f89ac66198c13616cc80e4bf158342d6c9","title":"","text":"Compiling project with causes the following compilation error: See this .\ncc target maintainer\nI guess has the same issue? This got broken by (\"unix time module now return result\") which dropped I guess the way forward is to make use instead. I'm wondering if there is a way to make sure that this kind of breakage doesn't happen before a rustc release?\nOur platform support policy is to avoid blocking PRs on whether tier 3 platforms build, because tier 3 platforms are not required to build.\nSure, I'm not saying to block PRs, but I'm wondering about somehow getting notified quickly enough to be able to react before a rustc release.\n(as in: getting the break notice from a getrandom CI build a dozen days after the merge does not look that robust)\nHm. Does the Rust compiler for hurd get built from a stable or beta branch of rustc? My understanding was that tier 3 targets generally used the nightly compiler in any case.\nIn Debian we will use the stable releases to compile all rust-needing Debian packages, as the Debian policy requires.\nThe breaking commit is not in the current 1.77 release but is in the 1.78 beta. It will not be in a stable release for another 5 weeks-ish. Would you like your PR that fixes it to be beta-nominated, so that it gets backported and is in the stable release of 1.78?\nYes, please.\nI recommend you set up a daily/weekly job on your side building master to check for regressions. ( may fix this)"}
{"_id":"doc-en-rust-2f15b74a95299f559142cae3dbc4bb94db05427621a9bd0c13b8207a4a751378","title":"","text":"I wanted to try out the missingdoccodeexamples rustdoc lint, but it seems to be bugged. I tried following the example given in . Steps to reproduce: Create a new crate: Then edit the file: I would now expect to get a linting error when building the crate, since the add function is public, but does not have a code example. However, as well as and completes without any errors.\nThe lint only works on nightly, the docs should probably be updated.\nThese docs live in To fix this, add 'and is nightly-only' to the first sentence.\nI created PR to update the documentation. Thanks for clarifying. :-)"}
{"_id":"doc-en-rust-ab673e532e457140214dc1a9d6605ec7269c0e2a977a3bc6ded94c5dc20eb855","title":"","text":"Was working on bug and tried to compile the program below. The inline assembly may be bogus: I make no guarantees of its correctness. crashed with this output: : (but also happened on a nightly from late May)\nThe inline assembly is in fact bogus. Here's a minimal example that crashes the compiler. The problem is likely using the string operand (by mistake, because I'm dumb).\n<details<summarybacktrace</summary</details\nmodify labels: I-ICE T-compiler A-inline-assembly C-bug\nThank you!"}
{"_id":"doc-en-rust-14619b0298e375a18f7e233cd65e1cf24f8130d969609168a70256fd6bbe212f","title":"","text":"The code around opt-levels indicates only nightly can use or . Non-nightly s should not even report those values as possible options."}
{"_id":"doc-en-rust-f3599eaa0d5a70ad41aa64f6fe971e48f558bf0d4d397deff83c6415231d57cb","title":"","text":"Added in these options are still unstable, this issue will track their progress to becoming stable!\nAlso note that is adding Cargo support, currently through and , but as we may want more human readable names.\nI don't even think there is a single word that describes what does. As far as I know it was first introduced in clang and selected for its closeness to and connotations of compression, but this doesn't help at all when you need an immediately understandable token in\n/ for and for ?\nis right, \"s\" and \"z\" are not clear at all. I had no idea what \"z\" even did until I looked it up. it is the same as \"s\" but without loop vectorisation. According to it is intended to reduce size even further. I like the \"size-1\"/\"size-2\" idea.\nWe are potentially interested in this for Gecko's integration of Rust code, see [1]. We'd need to do more measurements to determine if the performance impact is acceptable though. [1]\nthanks for the info! We haven't seen a lot of movement here in awhile and we've got support in Cargo/build scripts now, so I'd like to propose we stabilize this: fcp merge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged teams: [ ] [x] [x] [ ] [ ] [x] [x] [x] [x] [x] [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.\nIS this properly documented? That can come after we've approved for stability, right?\ngood point! I think we should definitely make sure it's documented at least in or the various man pages.\nyes, that should come before the final PR itself lands though.\nIt seems like there was an open concern that these tokens (especially for Cargo) aren't very clear. Do we want to take a short at single-word tokens before stabilizing?\nI'm not personally motivated to do so as this is such a niche feature it seems like it's not worth the effort, but others may feel differently.\nI feel differently!"}
{"_id":"doc-en-rust-41880baf17eba19529cf7bac10480e4f97f2dcb7d2bf22e99b4a80d2628f4cda","title":"","text":"If I change the patch to , and would that be acceptable? Or is it too late since Cargo has already merged and ? If so then we should probably stick with that but they should be properly documented since clearly very few people know what they mean.\nI think we're definitely still able to change, we just might have to have a small period of time where we support everything to deprecate s/z\nis there any particular reason that, for Cargo, we need more than just ? In practice, the main historical distinction between and was that was OSX-specific, and gave you \"definitely, for realz optimize for size.\" As far as I can tell, Cargo really only needs a way for people to say \"I want you to optimize for size, please\" and having multiple different versions of \"optimize for size\" at the Cargo level seems likely to introduce more confusion than help. I propose that we add to Cargo, and not leak and . I think I feel the same way about but don't have as strong of an opinion there.\nSounds plausible to me! In that case sounds like there's work to do, so I'll cancel the FCP fcp cancel\nproposal cancelled.\nThat's not what does, as far as I can tell. According to Clang's manual: Also see . By the way, there is also ! , which is: Sounds like it could be useful. I suggest for that.\nI came here because I wasn't sure what -Oz did - now I know. I would like to point out that \"size1\" and \"size2\" is not much better, imho. Ok, so there's a size difference. But which one is supposed to be smaller? The bigger number, because it tries more agressively to make it smaller, or the smaller number, for intuitive reasons? I can see the parallel with O1, O2, O3 -increasing optimization for speed, and S1, S2, S3 -increasing optimization for size, but perhaps this should be made more explicit then? We can always keep \"s\", \"o\", and so on as shorthand aliases\nHello This seems to have gone to sleep. I mean, the name for it is important, but no discussion seems to be happening for like 9 months ‒ is it likely to move forward?"}
{"_id":"doc-en-rust-7dac671fc42b10daf91eb420fffae17e35642c05ea87f7afcdb8806c5004d080","title":"","text":"As for me, I'd rather have the feature stabilized (I'm often aiming at devices with chronic lack of storage space), no matter the actual values used. Or is it blocked on anything else beside choosing the right name?\nSide note: the crash in only reproduces with -Os (probably an LLVM bug)\nSince the lastest LLVM upgrade rustc / LLVM does more agressive ~inlining~ loop unrolling. This results in increased binary size of embedded / no_std programs: a hundreds of bytes increase, or about a 7x increase, in the case of the smallest Cortex-M binary cf. . As we are shooting for embedded Rust on stable it would be great to also provide a way to optimize for size (which is pretty important for embedded applications that target resource constrained devices) on stable. What can we do to move this forward. Can we at least stabilize \"s\" on rustc? Cargo already allows in the but requires a nightly toolchain. is this (opt-level) being discussed as part of the Cargo profile revamp?\nI think those optimizations have baked long enough that it should be fine to stabilize now personally!"}
{"_id":"doc-en-rust-8aa959567ac0c02e8f8cad1807abf12cfd027bb28e08f60e89c6d85907a2638b","title":"","text":"The following code : run under miri reports UB:\ncc\nThe underlying issue is in : this has the same error.\nThis is actually tricky, I think -- an unexpected consequence of the Stacked Borrows rules. When is being passed to , it gets reborrowed and then \"protected\", meaning the mutable reference passed to must outlive that function call. But then it goes ahead and reads the old reference from directly via the raw pointer, which reborrows that reference, therefore invalidating the earlier other reborrow. There is a sense in which the reborrow of passed to is truly invalidated here -- and in fact it is not possible to access that value later: I am surprised by this error, since usually mutable references are reborrowed, not moved. But it seems here it somehow knows not to reborrow?\ncc -- could be related? Fully-qualifying the call with yields a different error (where reborrowed rather than moved), so it seems at least partially related:\nAh, yes that's it. Not that the exact error makes such a big difference, but now at least it is more clear that the reborrow makes later uses of fail.\nType inference will prevent reborrowing from happening.\nCould we say that a mutable reference that comes from a type parameter shouldn't be protected?\nThat seems a bit strange, to have a particular instance of a generic function behave differently than if that same instance had been written monomorphically.\nWell, generic function is different from an monomorphic function. In a monomorphic function you can dereference the reference, but (if there're no bounds) then in generic function you just have and would need to treat it \"just as data\" and the fact it's monomorphized to be a reference shouldn't be special. I.e. I would expect a to behave more closely to or than a dedicated, say type. It is strange to me that two monomorphized versions of the same function should behave differently.\nSure, a monomorphic function can be changed to do more things. But when a generic and monomorphic function are the same in the source code, they also should behave the same. They use completely different types, so them behaving the same does not even make sense? Like, e.g., will literally return different values. In general, two monomorphized versions of the same function have no choice but to behave differently."}
{"_id":"doc-en-rust-48dd4594cbfb0b8637e72773e9d28e74ebbac4405425e45ba0a60cf1bc8e899a","title":"","text":"To give another example, if you a to , then again of course this is UB for some (e.g., ) but totally fine for others (e.g., )."}
{"_id":"doc-en-rust-f75243581a6e3b035f28830a531667f99b42542c441bd2799c2a515831f959b4","title":"","text":"STR: run with on a program with a name resolution error. Result: cc (bug manifests in the RLS)\nI can take this. I already dug into some time ago, I encountered the same bug when I was trying to write a refactoring tool. To fix the issue, I have to remove all the around there, right ?\ngreat, thanks for digging in. There's likely to be some s that don't need to be there, but it won't be quite as simple as just ripping them out. There will be some error condition that needs to be dealt with."}
{"_id":"doc-en-rust-d884f00e678538a5565bf540b39e72304f9db1780692eb037221c922782010fb","title":"","text":"Note: The regression is valid/\"allowed\" (there's a hole in the typesystem being patched), I'm just filing this issue now so we can make sure that this regression is tracked in case it got \"fixed\" by accident. Feel free to close if it's a known quantity; I'm just worried that this got \"accidentally\" fixed in some other change. My crate is being fixed to not face this problem, but in general there's a chance other crates are falling afoul of this as well; we should perhaps assess the impact and start off with it being a future incompatibility warning if necessary. I tried this code: () I expected to see this happen: It compiles, like it does on stable, or at least throws a future incompatibility warning. Instead, this happened: It errors: It most recently worked on: Rust 1.56.0\nThis regressed in , which was a rollup. Further testing shows this resulted from . It's marked as being a partial revert, so I'm not entirely sure what the chronology is here. CC Note that we think this \"regression\" probably isn't actually a problem, per the note at the top.\nWhat the....\nOkay so reverting fully also errors. Stable 1.55.0 fails. Checking (a couple commits before ) now, but I'm assuming it's going to error. So, this was actually a bug in 1.56.0 - prior to that, this didn't compile, rightfully. My guess is because of treating unnormalized function args & output as WF, we saw , replaced it with , assumed that was WF, so we didn't actually check that . I'm going to go ahead and make a PR to add a test that closes this issue. This was a bug in 1.56.0, not a regression since.\nGood to know, thanks! (And good that this was just a one-version regression; less chance of there being in-the-wild breakage)\nI should figure out an excuse to make yoke a dependency of rustc, it seems really good at finding typesystem corner cases and maybe we should just have it be a test\nIsn't it failing on the wrong line?"}
{"_id":"doc-en-rust-9f10a579dafcdf8a691d6588be4b9c0309c1ac324fade573757e39f745f1763b","title":"","text":"I would have expected it to fail on the because is the thing that needs to match\nHaha yeah, it's a thorn in my side So, it's interesting. The check is , which is true. What I might expect here is it to fail because you haven't written (which is required for to be well-formed. But I think this is implied bounds, since this is fine:\nIn my experience WFness of has always been a bit variable where sometimes you can assume it and sometimes it requires you to spell it out, so maybe this is another instance of that.\nThanks!"}
{"_id":"doc-en-rust-6ad584234a87dd4ce0139c9775ae036e31869573927c0037d3a16276338b3e5c","title":"","text":"We currently emit vec growth glue, but it is called using the push/pop mechanism (e.g. of transcallglue). In reality, the only call site for this glue is generated when translating vec append statements, so it really is user-level glue and need not adhere to the \"worst-case glue-call args\" max argument count. The fact that we don't do this costs us one extra word of worst-case glue-call args at the moment (7 words instead of the 6 we'd need otherwise). This is a relatively minor issue, but now noted.\nWONTFIX (not required for bootstrapping)"}
{"_id":"doc-en-rust-6f04471aa769edcf2ac894521aed5ab2886f2f87af17ee8420798ac5cf721630","title":"","text":"Currently, pointers stored on the stack aren't word-aligned. This is a critical issue because it causes stack growth to fail most of the time.\nCommit disables task growth for now until this is fixed.\nWONTFIX (moot point given disabled stack growth)"}
{"_id":"doc-en-rust-81d30f2b1146e344adbac5cce6e75d0fedb3f44df8ca4e84c97950227a28b2cd","title":"","text":"u32(1234) should be 1234u32, and handled in the lexer The former is chatty and confuses the issue with runtime calls / casts (the latter of which should be shifted to 'as' casts anyway).\nSwitch machine-type lexemes to use suffixes. Remove support for foo(bar) as a cast notation. Closed by ."}
{"_id":"doc-en-rust-bbb4efa2b3a21d629817f1bbffcc35a010f2e6146e5a3a7af8be374fc1509d61","title":"","text":"This error occurred when running . Should I remove these unused attributes?\nWhat's your ? These should only warn, not error.\nThis is a part of my which is not commented out.\nIf you run and check again, these warnings should go away. It would be nice if this wasn't necessary, though.\nThank you for your advice! clean and then build completed successfully!\nThis happens to me every time I try to do an incremental build after making a change. Is there any other way to resolve this than ?\nLet's keep this issue open, because we'd rather not have to clean even single time.\nI'm running into the same problem with incremental builds, which makes incremental kind of useless...\nI think I am also running into this. I'm going to tag this T-compiler to try to increase visibility\nI am also running into this\nThis is super painful, can this gets prioritized, or could we disable incremental builds until its fixed?\nFYI, the following command seems like a pretty reliable way to reproduce this problem:\n(assigning to self to investigate)\nStrange; part of the problem I have had in investigating this is that it seemed like my manual attempts to run the \"same\" commands that were being issued by bootstrap would all complete successfully. I think part of the issue there is that the mode for is sometimes hiding information about the commands it runs. To get something that actually reproduced the problem, I had to drop into the \"more verbose\" mode by passing twice to , like so: and an interesting part about that output is that I saw these two lines right next to each other in the output: The first command listed won't reproduce the problem. The second will. (I suspect its because the first is lacking that that is present in the second.)\nAlso, setting this to may provide an easier workaround for this speciifc bug than a full clean:\n(The aforementioned setting was moved into rustbuild in )\nI am getting an increasing feeling that we need to document and simplify the bootstrapping process better...\nMy hope is that once PR gets into the beta-channel, then we should not see this particular problem arise. I would like to know if anyone is seeing other warnings that are not covered by the cases I handled in PR .\nThis is fixed now, right?\nI haven't encountered it since\nSame here. Seems to be working. Thanks\nclosing as fixed."}
{"_id":"doc-en-rust-30a8fd21f34d37accf2aedb6b03da91d31ba860cb4c8f8347ff53da9228dcd73","title":"","text":"Fixed on my end as well, thank you all!\nSeeing this one here: ie. I attempted some kind of whitelisting just as you did in PR , but I'm thinking it will only work if I attempt recompilation with a rustc that has that whitelisted already?(which would explain why it keeps failing as if whitelisting it had no effect, ok definitely placing garbage instead of the below patch(which should compile fail) does have no effect which says that it doesn't get compiled before the above fail) Either way, I'm not sure where to Whitelist it, since it appears as too: (notice how the filename moved: is now ) Something extra: If I put in (which overrides the stage0 rust / / ) then it compiles ok the first time(as expected) then if I interrupt it and then attempt (re)compile, I get now:\nThis keeps happening to me with this:\nI'm reopening and nominating for compiler team since it seems like it may be worth discussing to see if there's some principled solution for bugs like this. I think we've seen the last 2-3 releases all introduce at least one case of unused attribute errors in libcore/libstd during incremental, which is not great. Maybe there's some way we can stop tracking the rustc-perma-unstable attributes as 'green' in incremental? That may be too big a hammer though (or maybe too small). At least, it seems worth bringing this up at pre-triage.\nThis keeps happening to me when switching from to . Very annoying to have to . :(\ntriage: P-high, leaving nominated in hopes of discussion in a near term meeting.\nThere is a way of dealing with side-effects in the incremental system. We use such a solution for diagnostics. It could probably be expanded to unused-attributes if there is no cleaner approach.\nremoving nomination label; I'll follow-up with directly on ways to resolve this. (And/or discuss removing lint with )\nShould we just demote to warn-only at stage0? It's getting pretty boring to nuke every time I rebase and something has changed in libstd (looks even more frequent nowadays), and I've heard people say they don't set in because of these \"unused attribute\" errors, which is a shame."}
{"_id":"doc-en-rust-ca60d946ed463f51667ea3f96da866b6fee023124fa35752f4a9370c50d5bbeb","title":"","text":"IMO should be the default for dev builds, although there's also the wasteful duplication between build artifacts and incremental dirs (for which I've just opened ).\nOpened for the \"temporary workaround\".\nJust FYI, landed, please leave a comment here if you still hit this issue. (it might move from libcore to other crates, not sure)"}
{"_id":"doc-en-rust-c58f7b7660477a36d4f4e0b97257ff6dd013746ba8d66ba6cc4a6a220b7b64ed","title":"","text":"The message for E0139 suggests replacing with . Actually performing such a replacement will result in double drops, since the version consumes but the version does not. (It presumably needs a or something.)"}
{"_id":"doc-en-rust-b42b6ef93bee4d7180bb7d77309475fb36bc4cc78a287c17c9828feb5e3fa4cb","title":"","text":"On currently nightly, I get: () Yet the description for this error was merged weeks ago:\ncc , in the future when adding new diagnostics mods be sure to add a call"}
{"_id":"doc-en-rust-c141435671b4f5bac4d731331201b6ba860db6fb2cd3599591f1400b2c8986db","title":"","text":"The compiler seems unable to determine that two types are equal. I tried this code: I expected the program to compile and run without issue, because is , so the call should be fine. Instead, I got this error message: The problem exists on stable 1.42 and nightly 1.44\nIt somehow compiles if you replace the associated type with a type parameter:\ncc /\nPossibly relevant rustc log entries: Seems like the will resolve the inference variable to yield , but for some reason is unable to normalize that further.\nIt seems like the opaque type has a substs with only in it; on first glance I'd have expected the projection there, but the docs on do explain this: So it seems like the is what was inserted for the type parameter, making . I'm not sure why this is represented like it is, but it seems like we need more info to be able to look at the real substs of the opaque type.\nDuh, I forgot how opaque types work. Not sure where would be stored (? It's empty at this point according to log), but it's definitely not in the type, so this output makes sense.\nThis is fixed on nightly."}
{"_id":"doc-en-rust-26f0312e80780bedd14d9f98731fcff6e2caee27f3342d480a846f83dc2b2703","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! And nominating for compiler team prioritization.\nMiri fix:\nThis appears to be fixed\nWe fixed it in the Miri repo but have not yet updated the rustc repo for that. Let's keep the issue open until that happened.\nApologies! Where should I check in the future to be sure it's fixed?\nNo worries. :) You can check the toolstate page: https://rust-lang- (Or you can skip these miri issues if that's easier for you; I think I am taking care of them quite well -- though more eyes and more help are of course always appreciated.)\nThanks, gonna bookmark that. I was going through unlabeled issues which is how I stumbled here.\nHm, we could maybe have the bot that creates them also automatically apply \"A-miri C-bug\" or so... Cc"}
{"_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!"}