Convert `delayed_bug`s to `bug`s. #121208

nnethercote · 2024-02-16T23:39:52Z

I have a suspicion that quite a few delayed bug paths are impossible to reach, so I did an experiment.

I converted every delayed_bug to a bug, ran the full test suite, then converted back every bug that was hit. A surprising number were never hit.

This is too dangerous to merge. Increased coverage (fuzzing or a crater run) would likely hit more cases. But it might be useful for people to look at and think about which paths are genuinely unreachable.

r? @ghost

rustbot · 2024-02-16T23:39:56Z

Some changes might have occurred in exhaustiveness checking

cc @Nadrieril

Some changes occurred in const_evaluatable.rs

cc @BoxyUwU

Some changes occurred to MIR optimizations

cc @rust-lang/wg-mir-opt

Type relation code was changed

cc @compiler-errors, @lcnr

nnethercote · 2024-02-16T23:40:04Z

cc @compiler-errors @oli-obk @lcnr

lcnr

I think we should land this with at least a few of these converted to bugs. I think doing so is fine because either:

I am fairly confident that this can be a bug!, the code is familiar and I believe it to be unreachable.
anything triggering that ICE should be self-contained and easy to minimize, meaning that even if it's reachable, we should be able to get a new ui test fairly quickly, which is worth it.

Went through all changes rn and I would like to push this through and merge it after handling all review comments. we still have nearly a month until the next beta cutoff, so we could merge this now.

lcnr · 2024-02-19T08:24:33Z

compiler/rustc_ast_lowering/src/lib.rs

-                        self.dcx()
-                            .span_delayed_bug(lifetime.ident.span, "no def-id for fresh lifetime");
-                        continue;
+                        self.dcx().span_bug(lifetime.ident.span, "no def-id for fresh lifetime");


lcnr · 2024-02-19T08:25:46Z

compiler/rustc_borrowck/src/diagnostics/region_name.rs

@@ -628,7 +628,7 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
                ) => {
                    // HIR lowering sometimes doesn't catch this in erroneous
                    // programs, so we need to use span_delayed_bug here. See #82126.
-                    self.dcx().span_delayed_bug(
+                    self.dcx().span_bug(


the original UI test for #82126 does not trigger this anymore, so we should get a new test if it's still reachable. Please update the comment before merge

2

lcnr · 2024-02-19T08:27:39Z

compiler/rustc_borrowck/src/type_check/free_region_relations.rs

@@ -316,8 +316,7 @@ impl<'tcx> UniversalRegionRelationsBuilder<'_, 'tcx> {
                    .and(type_op::normalize::Normalize::new(ty))
                    .fully_perform(self.infcx, span)
                else {
-                    tcx.dcx().span_delayed_bug(span, format!("failed to normalize {ty:?}"));
-                    continue;
+                    tcx.dcx().span_bug(span, format!("failed to normalize {ty:?}"));


feels like this should be reachable and potentially hard to minimize, please keep this a span_delayed_bug but maybe add a comment "this is currently not reached in any test, so it may be worth it to minimize an example triggering this".

lcnr · 2024-02-19T08:27:48Z

compiler/rustc_borrowck/src/type_check/input_output.rs

@@ -154,8 +154,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
            if argument_index + 1 >= body.local_decls.len() {
                self.tcx()
                    .dcx()
-                    .span_delayed_bug(body.span, "found more normalized_input_ty than local_decls");


lcnr · 2024-02-19T08:28:49Z

compiler/rustc_borrowck/src/type_check/mod.rs

            trace!("finalized opaque type {:?} to {:#?}", opaque_type_key, hidden_type.ty.kind());
            if hidden_type.has_non_region_infer() {
-                let reported = infcx.dcx().span_delayed_bug(
+                infcx.dcx().span_bug(


1

not as confident as I maybe should be, but I would really like a test for cases where this is triggered if reachable.

lcnr · 2024-02-19T09:07:46Z

compiler/rustc_trait_selection/src/traits/project.rs

@@ -2016,11 +2016,10 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
            ImplSource::Builtin(BuiltinImplSource::TraitUpcasting { .. }, _)
            | ImplSource::Builtin(BuiltinImplSource::TupleUnsizing, _) => {
                // These traits have no associated types.
-                selcx.tcx().dcx().span_delayed_bug(
+                selcx.tcx().dcx().span_bug(


probably theoretically reachable when manually redefining their lang item 🤷 so we should keep it as a delay span bug

lcnr · 2024-02-19T09:08:51Z

compiler/rustc_trait_selection/src/traits/query/type_op/custom.rs

@@ -82,7 +82,7 @@ where
    let value = infcx.commit_if_ok(|_| {
        let ocx = ObligationCtxt::new(infcx);
        let value = op(&ocx).map_err(|_| {
-            infcx.dcx().span_delayed_bug(span, format!("error performing operation: {name}"))
+            infcx.dcx().span_bug(span, format!("error performing operation: {name}"))


theoretically reachable I think, may make sense to still keep this as is to get a test 🤷 easier to just keep a span_delay_bug here

lcnr · 2024-02-19T09:09:49Z

compiler/rustc_trait_selection/src/traits/query/type_op/mod.rs

-                ));
+                infcx
+                    .dcx()
+                    .span_bug(span, format!("ambiguity processing {obligations:?} from {self:?}"));


i think it's currently unreachable, but that may change going forward. Still Making it a bug seems alright to me

lcnr · 2024-02-19T09:10:08Z

compiler/rustc_ty_utils/src/layout.rs

@@ -90,8 +90,7 @@ fn univariant_uninterned<'tcx>(
    let dl = cx.data_layout();
    let pack = repr.pack;
    if pack.is_some() && repr.align.is_some() {
-        cx.tcx.dcx().delayed_bug("struct cannot be packed and aligned");
-        return Err(cx.tcx.arena.alloc(LayoutError::Unknown(ty)));
+        cx.tcx.dcx().bug("struct cannot be packed and aligned");


lcnr · 2024-02-19T09:10:21Z

compiler/rustc_ty_utils/src/opaque_types.rs

@@ -337,7 +337,7 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for ImplTraitInAssocTypeCollector<'tcx> {
                                .instantiate(self.0.tcx, impl_args)
                                .visit_with(self);
                        } else {
-                            self.0.tcx.dcx().span_delayed_bug(
+                            self.0.tcx.dcx().span_bug(


lcnr · 2024-02-19T09:14:30Z

r? @lcnr

nnethercote · 2024-02-19T23:08:04Z

Thanks for the amazingly thorough review! I think I have made all the changes you requested.

@matthiaskrgr: would you mind fuzzing this for a bit before we merge? It would be good to get some extra coverage.

@bors try

[Experiment] Convert `delayed_bug`s to `bug`s. I have a suspicion that quite a few delayed bug paths are impossible to reach, so I did an experiment. I converted every `delayed_bug` to a `bug`, ran the full test suite, then converted back every `bug` that was hit. A surprising number were never hit. This is too dangerous to merge. Increased coverage (fuzzing or a crater run) would likely hit more cases. But it might be useful for people to look at and think about which paths are genuinely unreachable. r? `@ghost`

bors · 2024-02-19T23:09:15Z

⌛ Trying commit 5f00f10 with merge 4d96544...

bors · 2024-02-20T00:36:57Z

☀️ Try build successful - checks-actions
Build commit: 4d96544 (4d96544a124b8a36849185bddcfe6f87520c120e)

matthiaskrgr · 2024-02-20T11:18:00Z

I've run this through roughly 850000 files x 6 different sets of rustcflags on the dev desktop server and didn't see any crashes that would strike me as new 👍
around 650 crashes were found in total, coming down to around 50 "unique" crashes.

lcnr · 2024-02-20T16:49:11Z

compiler/rustc_hir_typeck/src/intrinsicck.rs

@@ -48,8 +48,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
        let to = normalize(to);
        trace!(?from, ?to);
        if from.has_non_region_infer() || to.has_non_region_infer() {
+            // Note: this path is currently not reached in any test, so any
+            // example that triggers this would be worth minimizing and
+            // converting into a test.
            tcx.dcx().span_delayed_bug(span, "argument to transmute has inference variables");


should this not be a span_bug? After removing the return we now use the below code even if there are infer vars

lcnr · 2024-02-20T16:49:44Z

compiler/rustc_hir_analysis/src/check/wfcheck.rs

-                    } else {
-                        ty.needs_drop(tcx, tcx.param_env(item.owner_id))
-                    }
+                    assert!(!ty.has_infer());


Suggested change

assert!(!ty.has_infer());

lcnr · 2024-02-20T16:50:41Z

compiler/rustc_infer/src/infer/outlives/verify.rs

@@ -172,6 +172,7 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
                self.bound_from_components(components, visited)
            }
            Component::UnresolvedInferenceVariable(v) => {
+                // njn: comment?


lcnr · 2024-02-20T16:50:58Z

compiler/rustc_infer/src/infer/relate/nll.rs

-                    format!("unexpected inference var {b:?}",),
-                );
-                Ok(a)
+                self.infcx.dcx().bug(format!("unexpected inference var {b:?}"));


bug vs span_bug?

You want me to use span_bug? What span would I use?

self.delegate.span()? the same we previously used in the span_delayed_bug 🤔

Oh, I removed that because of this comment. Maybe I misinterpreted what you were asking for.

ah xd, yeah 😁 i messed that up, didn't look at the context in my second review 😅 sorry

lcnr · 2024-02-20T16:51:31Z

compiler/rustc_middle/src/util/bug.rs

@@ -42,7 +42,7 @@ fn opt_span_bug_fmt<S: Into<MultiSpan>>(
 /// delayed bug, so what is the point of this? It exists to help us test the interaction of delayed
 /// bugs with the query system and incremental.
 pub fn trigger_delayed_bug(tcx: TyCtxt<'_>, key: rustc_hir::def_id::DefId) {
-    tcx.dcx().span_delayed_bug(
+    tcx.dcx().span_bug(


still needs to get converted back

lcnr · 2024-02-20T16:52:06Z

compiler/rustc_mir_build/src/build/expr/as_constant.rs

-                .size;
+        let width = tcx
+            .layout_of(param_ty)
+            .expect(&format!("couldn't compute width of literal: {:?}", lit_input.lit))


now eagerly formats even in the success case, which is unnecessary work and may negatively impact perf

lcnr · 2024-02-20T16:52:11Z

compiler/rustc_mir_build/src/thir/constant.rs

-                .size;
+        let width = tcx
+            .layout_of(param_ty)
+            .expect(&format!("couldn't compute width of literal: {:?}", lit_input.lit))


lcnr · 2024-02-20T16:52:45Z

compiler/rustc_resolve/src/late.rs

@@ -3682,13 +3682,13 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
                None
            }
            Res::SelfCtor(_) => {
+                // njn: remove comment?


still relevant

lcnr · 2024-02-20T16:55:12Z

compiler/rustc_trait_selection/src/traits/const_evaluatable.rs

+                // njn: ?
                // FIXME(generic_const_exprs): we have a `ConstKind::Expr` which is fully concrete,
                // but currently it is not possible to evaluate `ConstKind::Expr` so we are unable
                // to tell if it is evaluatable or not. For now we just ICE until this is
                // implemented.


Suggested change

// njn: ?

// FIXME(generic_const_exprs): we have a `ConstKind::Expr` which is fully concrete,

// but currently it is not possible to evaluate `ConstKind::Expr` so we are unable

// to tell if it is evaluatable or not. For now we just ICE until this is

// implemented.

// FIXME(generic_const_exprs): we have a fully concrete `ConstKind::Expr`,

// but haven't implemented evaluating `ConstKind::Expr` yet, so we

// are unable to tell if it is evaluatable or not. As this is

// unreachable for now, we can simple ICE here.

nnethercote · 2024-02-20T22:52:00Z

@lcnr: Ok, I think I've addressed all the new comments, except for this one.

@matthiaskrgr: thank you for the fuzzing! That's very helpful.

lcnr · 2024-02-20T23:02:31Z

r=me after addressing the last comment

I have a suspicion that quite a few delayed bug paths are impossible to reach, so I did an experiment. I converted every `delayed_bug` to a `bug`, ran the full test suite, then converted back every `bug` that was hit. A surprising number were never hit. The next commit will convert some more back, based on human judgment.

This commit undoes some of the previous commit's mechanical changes, based on human judgment.

nnethercote · 2024-02-21T00:24:12Z

@bors r=lcnr

bors · 2024-02-21T00:24:15Z

📌 Commit 2903bbb has been approved by lcnr

It is now in the queue for this repository.

Rollup merge of rust-lang#121620 - nnethercote:fix-even-more-121208-fallout, r=lcnr Fix more rust-lang#121208 fallout (round 3) rust-lang#121208 converted lots of delayed bugs to bugs. Unsurprisingly, there were a few invalid conversion found via fuzzing. r? `@lcnr`

PR rust-lang#121208 converted this from a `span_delayed_bug` to a `span_bug` because nothing in the test suite caused execution to hit this path. But now fuzzing has found a test case that does hit it. So this commit converts it back to `span_delayed_bug` and adds the relevant test.

PR rust-lang#121208 converted this from a `span_delayed_bug` to a `span_bug` because nothing in the test suite caused execution to hit this path. But now fuzzing has found a test case that does hit it. So this commit converts it back to `span_delayed_bug` and adds the relevant test. Fixes rust-lang#126385.

Convert a `span_bug` to a `span_delayed_bug`. PR rust-lang#121208 converted this from a `span_delayed_bug` to a `span_bug` because nothing in the test suite caused execution to hit this path. But now fuzzing has found a test case that does hit it. So this commit converts it back to `span_delayed_bug` and adds the relevant test. Fixes rust-lang#126385. r? `@lcnr`

Rollup merge of rust-lang#126570 - nnethercote:fix-126385, r=lcnr Convert a `span_bug` to a `span_delayed_bug`. PR rust-lang#121208 converted this from a `span_delayed_bug` to a `span_bug` because nothing in the test suite caused execution to hit this path. But now fuzzing has found a test case that does hit it. So this commit converts it back to `span_delayed_bug` and adds the relevant test. Fixes rust-lang#126385. r? `@lcnr`

For the code pattern reported in <rust-lang#133272>, ```rs impl Foo { fn fun() { let S { ref Self } = todo!(); } } ``` <rust-lang#121208> converted this to a `span_bug` from a `span_delayed_bug` because this specific self-ctor code pattern lacked test coverage. It turns out this can be hit but we just lacked test coverage, so change it back to a `span_delayed_bug` and add a target tested case.

…-errors Re-delay a resolve `bug` related to `Self`-ctor in patterns For the code pattern reported in <rust-lang#133272>, ```rs impl Foo { fn fun() { let S { ref Self } = todo!(); } } ``` <rust-lang#121208> converted this to a `span_bug` from a `span_delayed_bug` because this specific self-ctor code pattern lacked test coverage. It turns out this can be hit but we just lacked test coverage, so change it back to a `span_delayed_bug` and add a targeted test case. Follow-up to rust-lang#121208, cc `@nnethercote` (very good exercise to expose our test coverage gaps). Fixes rust-lang#133272.

…-errors Re-delay a resolve `bug` related to `Self`-ctor in patterns For the code pattern reported in <rust-lang#133272>, ```rs impl Foo { fn fun() { let S { ref Self } = todo!(); } } ``` <rust-lang#121208> converted this to a `span_bug` from a `span_delayed_bug` because this specific self-ctor code pattern lacked test coverage. It turns out this can be hit but we just lacked test coverage, so change it back to a `span_delayed_bug` and add a targeted test case. Follow-up to rust-lang#121208, cc ``@nnethercote`` (very good exercise to expose our test coverage gaps). Fixes rust-lang#133272.

…-errors Re-delay a resolve `bug` related to `Self`-ctor in patterns For the code pattern reported in <rust-lang#133272>, ```rs impl Foo { fn fun() { let S { ref Self } = todo!(); } } ``` <rust-lang#121208> converted this to a `span_bug` from a `span_delayed_bug` because this specific self-ctor code pattern lacked test coverage. It turns out this can be hit but we just lacked test coverage, so change it back to a `span_delayed_bug` and add a targeted test case. Follow-up to rust-lang#121208, cc ```@nnethercote``` (very good exercise to expose our test coverage gaps). Fixes rust-lang#133272.

…-errors Re-delay a resolve `bug` related to `Self`-ctor in patterns For the code pattern reported in <rust-lang#133272>, ```rs impl Foo { fn fun() { let S { ref Self } = todo!(); } } ``` <rust-lang#121208> converted this to a `span_bug` from a `span_delayed_bug` because this specific self-ctor code pattern lacked test coverage. It turns out this can be hit but we just lacked test coverage, so change it back to a `span_delayed_bug` and add a targeted test case. Follow-up to rust-lang#121208, cc ````@nnethercote```` (very good exercise to expose our test coverage gaps). Fixes rust-lang#133272.

…-errors Re-delay a resolve `bug` related to `Self`-ctor in patterns For the code pattern reported in <rust-lang#133272>, ```rs impl Foo { fn fun() { let S { ref Self } = todo!(); } } ``` <rust-lang#121208> converted this to a `span_bug` from a `span_delayed_bug` because this specific self-ctor code pattern lacked test coverage. It turns out this can be hit but we just lacked test coverage, so change it back to a `span_delayed_bug` and add a targeted test case. Follow-up to rust-lang#121208, cc `````@nnethercote````` (very good exercise to expose our test coverage gaps). Fixes rust-lang#133272.

…-errors Re-delay a resolve `bug` related to `Self`-ctor in patterns For the code pattern reported in <rust-lang#133272>, ```rs impl Foo { fn fun() { let S { ref Self } = todo!(); } } ``` <rust-lang#121208> converted this to a `span_bug` from a `span_delayed_bug` because this specific self-ctor code pattern lacked test coverage. It turns out this can be hit but we just lacked test coverage, so change it back to a `span_delayed_bug` and add a targeted test case. Follow-up to rust-lang#121208, cc `@nnethercote` (very good exercise to expose our test coverage gaps). Fixes rust-lang#133272.

…-errors Re-delay a resolve `bug` related to `Self`-ctor in patterns For the code pattern reported in <rust-lang#133272>, ```rs impl Foo { fn fun() { let S { ref Self } = todo!(); } } ``` <rust-lang#121208> converted this to a `span_bug` from a `span_delayed_bug` because this specific self-ctor code pattern lacked test coverage. It turns out this can be hit but we just lacked test coverage, so change it back to a `span_delayed_bug` and add a targeted test case. Follow-up to rust-lang#121208, cc ``@nnethercote`` (very good exercise to expose our test coverage gaps). Fixes rust-lang#133272.

Rollup merge of rust-lang#133286 - jieyouxu:bug-ourselves, r=compiler-errors Re-delay a resolve `bug` related to `Self`-ctor in patterns For the code pattern reported in <rust-lang#133272>, ```rs impl Foo { fn fun() { let S { ref Self } = todo!(); } } ``` <rust-lang#121208> converted this to a `span_bug` from a `span_delayed_bug` because this specific self-ctor code pattern lacked test coverage. It turns out this can be hit but we just lacked test coverage, so change it back to a `span_delayed_bug` and add a targeted test case. Follow-up to rust-lang#121208, cc ``@nnethercote`` (very good exercise to expose our test coverage gaps). Fixes rust-lang#133272.

Without doing so, we'll run into a series of delayed bugs then find that we have a `TyKind::Error` constructed yet fail to emit an error. This partially reverts a change in <rust-lang#121208> related to never type adjustments in expr typecheck errors.

… r=compiler-errors (Re-)return adjustment target if adjust kind is never-to-any This PR fixes rust-lang#134162 where we ICE'd on ```rs fn main() { struct X; let _ = [X] == [panic!(); 2]; } ``` In rust-lang#121208 (comment), there was a change ```diff - if let Some(adjustments) = self.typeck_results.borrow().adjustments().get(expr.hir_id) { - let reported = self.dcx().span_delayed_bug( - expr.span, - "expression with never type wound up being adjusted", - ); - return if let [Adjustment { kind: Adjust::NeverToAny, target }] = &adjustments[..] { - target.to_owned() - } else { - Ty::new_error(self.tcx(), reported) - }; - } + if let Some(_) = self.typeck_results.borrow().adjustments().get(expr.hir_id) { + self.dcx() + .span_bug(expr.span, "expression with never type wound up being adjusted"); + } ``` It turned out returning the adjustment target if the adjustment kind is `NeverToAny` is necessary, as otherwise we will go through a series of `delay_bug`s and eventually find that we constructed a `TyKind::Error` without having actually emitted an error. This PR addresses that by re-returning the adjustment target if the adjustment kind is `NeverToAny`, partially reverting this change from rust-lang#121208. This PR has two commits: 1. The first commit adds a regression test for rust-lang#134162, which will ICE (on stable 1.83.0, beta and nightly 2024-12-13). 2. The second commit is the partial revert, which will fix the ICE. cc `@nnethercote` FYI as this is related to rust-lang#121208 changes. The changes from rust-lang#121208 exposed that we lacked test coverage for the code pattern reported in rust-lang#134162.

Rollup merge of rust-lang#134279 - jieyouxu:return-adjustment-target, r=compiler-errors (Re-)return adjustment target if adjust kind is never-to-any This PR fixes rust-lang#134162 where we ICE'd on ```rs fn main() { struct X; let _ = [X] == [panic!(); 2]; } ``` In rust-lang#121208 (comment), there was a change ```diff - if let Some(adjustments) = self.typeck_results.borrow().adjustments().get(expr.hir_id) { - let reported = self.dcx().span_delayed_bug( - expr.span, - "expression with never type wound up being adjusted", - ); - return if let [Adjustment { kind: Adjust::NeverToAny, target }] = &adjustments[..] { - target.to_owned() - } else { - Ty::new_error(self.tcx(), reported) - }; - } + if let Some(_) = self.typeck_results.borrow().adjustments().get(expr.hir_id) { + self.dcx() + .span_bug(expr.span, "expression with never type wound up being adjusted"); + } ``` It turned out returning the adjustment target if the adjustment kind is `NeverToAny` is necessary, as otherwise we will go through a series of `delay_bug`s and eventually find that we constructed a `TyKind::Error` without having actually emitted an error. This PR addresses that by re-returning the adjustment target if the adjustment kind is `NeverToAny`, partially reverting this change from rust-lang#121208. This PR has two commits: 1. The first commit adds a regression test for rust-lang#134162, which will ICE (on stable 1.83.0, beta and nightly 2024-12-13). 2. The second commit is the partial revert, which will fix the ICE. cc `@nnethercote` FYI as this is related to rust-lang#121208 changes. The changes from rust-lang#121208 exposed that we lacked test coverage for the code pattern reported in rust-lang#134162.

…er-errors (Re-)return adjustment target if adjust kind is never-to-any This PR fixes #134162 where we ICE'd on ```rs fn main() { struct X; let _ = [X] == [panic!(); 2]; } ``` In rust-lang/rust#121208 (comment), there was a change ```diff - if let Some(adjustments) = self.typeck_results.borrow().adjustments().get(expr.hir_id) { - let reported = self.dcx().span_delayed_bug( - expr.span, - "expression with never type wound up being adjusted", - ); - return if let [Adjustment { kind: Adjust::NeverToAny, target }] = &adjustments[..] { - target.to_owned() - } else { - Ty::new_error(self.tcx(), reported) - }; - } + if let Some(_) = self.typeck_results.borrow().adjustments().get(expr.hir_id) { + self.dcx() + .span_bug(expr.span, "expression with never type wound up being adjusted"); + } ``` It turned out returning the adjustment target if the adjustment kind is `NeverToAny` is necessary, as otherwise we will go through a series of `delay_bug`s and eventually find that we constructed a `TyKind::Error` without having actually emitted an error. This PR addresses that by re-returning the adjustment target if the adjustment kind is `NeverToAny`, partially reverting this change from #121208. This PR has two commits: 1. The first commit adds a regression test for #134162, which will ICE (on stable 1.83.0, beta and nightly 2024-12-13). 2. The second commit is the partial revert, which will fix the ICE. cc `@nnethercote` FYI as this is related to #121208 changes. The changes from #121208 exposed that we lacked test coverage for the code pattern reported in #134162.

rustbot added S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. T-compiler Relevant to the compiler team, which will review and decide on the PR/issue. labels Feb 16, 2024

nnethercote marked this pull request as draft February 16, 2024 23:40

nnethercote changed the title ~~Convert delayed_bugs to bugs.~~ [Experiment] Convert delayed_bugs to bugs. Feb 16, 2024

This comment has been minimized.

Sign in to view

nnethercote force-pushed the delayed_bug-to-bug branch from 8f01448 to 7a9d32e Compare February 18, 2024 18:26

lcnr reviewed Feb 19, 2024

View reviewed changes

rustbot assigned lcnr Feb 19, 2024

nnethercote force-pushed the delayed_bug-to-bug branch from 7a9d32e to 5f00f10 Compare February 19, 2024 22:59

nnethercote marked this pull request as ready for review February 19, 2024 23:25

nnethercote changed the title ~~[Experiment] Convert delayed_bugs to bugs.~~ Convert delayed_bugs to bugs. Feb 19, 2024

lcnr reviewed Feb 20, 2024

View reviewed changes

nnethercote force-pushed the delayed_bug-to-bug branch from 5f00f10 to 83fa4f6 Compare February 20, 2024 22:50

nnethercote added 2 commits February 21, 2024 10:20

Convert bugs back to delayed_bugs.

2903bbb

This commit undoes some of the previous commit's mechanical changes, based on human judgment.

nnethercote force-pushed the delayed_bug-to-bug branch from 83fa4f6 to 2903bbb Compare February 21, 2024 00:24

bors removed the S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. label Feb 21, 2024

nnethercote mentioned this pull request Feb 27, 2024

Count stashed errors again #121669

Merged

matthiaskrgr mentioned this pull request Mar 16, 2024

ICE: should be sized but is not? #122581

Closed

matthiaskrgr mentioned this pull request Apr 4, 2024

ICE: argument to transmute has inference variables #123461

Closed

matthiaskrgr mentioned this pull request Jun 13, 2024

ICE: unmatched arg and hir arg: found '?1 vs Type #126385

Closed

nnethercote mentioned this pull request Jun 17, 2024

Convert a span_bug to a span_delayed_bug. #126570

Merged

jieyouxu mentioned this pull request Nov 21, 2024

ICE: unexpected 'SelfCtor' in pattern, expected identifier #133272

Closed

jieyouxu mentioned this pull request Nov 21, 2024

Re-delay a resolve bug related to Self-ctor in patterns #133286

Merged

jieyouxu mentioned this pull request Dec 11, 2024

ICE: this path really should be doomed #134162

Closed

jieyouxu mentioned this pull request Dec 13, 2024

(Re-)return adjustment target if adjust kind is never-to-any #134279

Merged

Convert delayed_bugs to bugs. #121208

Convert delayed_bugs to bugs. #121208

Conversation

nnethercote commented Feb 16, 2024

rustbot commented Feb 16, 2024

nnethercote commented Feb 16, 2024

This comment has been minimized.

lcnr left a comment • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

lcnr commented Feb 19, 2024

nnethercote commented Feb 19, 2024

bors commented Feb 19, 2024

bors commented Feb 20, 2024

matthiaskrgr commented Feb 20, 2024 • edited Loading

lcnr Feb 20, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

lcnr Feb 22, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

nnethercote commented Feb 20, 2024

lcnr commented Feb 20, 2024

nnethercote commented Feb 21, 2024

bors commented Feb 21, 2024

Convert `delayed_bug`s to `bug`s. #121208

Convert `delayed_bug`s to `bug`s. #121208

lcnr left a comment •

edited

Loading

matthiaskrgr commented Feb 20, 2024 •

edited

Loading

lcnr Feb 20, 2024 •

edited

Loading

lcnr Feb 22, 2024 •

edited

Loading