Commit 17c25e4

Browse files
ZalatharZalathar
authored
Rollup merge of #148872 - ShoyuVanilla:issue-148192, r=chenyukang
fix: Do not ICE when missing match arm with ill-formed subty is met Fixes#148192 The ICE comes from the following line, calling `normalize_erasing_regions` to a projection type whose trait bound is not met: https://github.com/rust-lang/rust/blob/2fcbda6c1a70606bdb09857e01d01fc6229da712/compiler/rustc_pattern_analysis/src/rustc.rs#L185-L194 The above function is called while trying to lint missing match arms, or scrutinize ctors of missing(not necessary error) match arms. So, the following code can trigger ICEs. ```rust trait WhereTrait { type Type; } fn foo(e: Enum) { match e { Enum::Map(_) => (), // ICE, while trying to lint missing arms } if let Enum::Map(_) = e {} // ICE, while trying to scrutinize missing ctors (even worse) } enum Enum { Map(()), Map2(<() as WhereTrait>::Type), } ``` This ICE won't be triggered with the following code, as this is filtered out before `check_match` as the existence of ill-formed type inside the variant marks the body as tainted by error in `hir_typeck`, but for the above code, the `hir_typeck` complains nothing because everything it sees is locally correct. ```rust fn foo(e: Enum) { match e { Enum::Map2(_) => (), // No ICE } } ``` I've considered visiting and wf checking for the match scrutinee before entering `check_match`, but that might regress the perf and I think just emitting delayed bug would enough as the normalization failure would be originated by other errors like ill-formdness.
2 parents 1f2d7db + dae003b commit 17c25e4

3 files changed

Lines changed: 69 additions & 1 deletion

File tree

‎compiler/rustc_pattern_analysis/src/rustc.rs‎

Lines changed: 12 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -191,7 +191,18 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
191191
variant.fields.iter().map(move |field| {
192192
let ty = field.ty(self.tcx, args);
193193
// `field.ty()` doesn't normalize after instantiating.
194-
let ty = self.tcx.normalize_erasing_regions(self.typing_env, ty);
194+
let ty =
195+
self.tcx.try_normalize_erasing_regions(self.typing_env, ty).unwrap_or_else(|e| {
196+
self.tcx.dcx().span_delayed_bug(
197+
self.scrut_span,
198+
format!(
199+
"Failed to normalize {:?} in typing_env={:?} while getting variant sub tys for {ty:?}",
200+
e.get_type_for_failure(),
201+
self.typing_env,
202+
),
203+
);
204+
ty
205+
});
195206
let ty = self.reveal_opaque_ty(ty);
196207
(field, ty)
197208
})

‎tests/ui/pattern/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs‎

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
traitWhereTrait{
2+
typeType;
3+
}
4+
5+
fnfoo(e:Enum){
6+
ifletEnum::Map(_) = e {}
7+
8+
match e {
9+
//~^ ERROR: non-exhaustive patterns: `Enum::Map2(_)` not covered
10+
Enum::Map(_) => (),
11+
}
12+
}
13+
14+
enumEnum{
15+
Map(()),
16+
Map2(<()asWhereTrait>::Type),
17+
//~^ ERROR: the trait bound `(): WhereTrait` is not satisfied
18+
}
19+
20+
fnmain(){}

‎tests/ui/pattern/missing-ctor-with-ill-formed-inner-ty-issue-148192.stderr‎

Lines changed: 37 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
error[E0277]: the trait bound `(): WhereTrait` is not satisfied
2+
--> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:16:10
3+
|
4+
LL | Map2(<() as WhereTrait>::Type),
5+
| ^^^^^^^^^^^^^^^^^^^^^^^^ the trait `WhereTrait` is not implemented for `()`
6+
|
7+
help: this trait has no implementations, consider adding one
8+
--> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:1:1
9+
|
10+
LL | trait WhereTrait {
11+
| ^^^^^^^^^^^^^^^^
12+
13+
error[E0004]: non-exhaustive patterns: `Enum::Map2(_)` not covered
14+
--> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:8:11
15+
|
16+
LL | match e {
17+
| ^ pattern `Enum::Map2(_)` not covered
18+
|
19+
note: `Enum` defined here
20+
--> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:14:6
21+
|
22+
LL | enum Enum {
23+
| ^^^^
24+
LL | Map(()),
25+
LL | Map2(<() as WhereTrait>::Type),
26+
| ---- not covered
27+
= note: the matched value is of type `Enum`
28+
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
29+
|
30+
LL ~ Enum::Map(_) => (),
31+
LL ~ Enum::Map2(_) => todo!(),
32+
|
33+
34+
error: aborting due to 2 previous errors
35+
36+
Some errors have detailed explanations: E0004, E0277.
37+
For more information about an error, try `rustc --explain E0004`.

0 commit comments

Comments
 (0)
, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
Commit 17c25e4
Browse files
ZalatharZalathar
authored
Rollup merge of #148872 - ShoyuVanilla:issue-148192, r=chenyukang
fix: Do not ICE when missing match arm with ill-formed subty is met
Fixes#148192
The ICE comes from the following line, calling `normalize_erasing_regions` to a projection type whose trait bound is not met:
https://github.com/rust-lang/rust/blob/2fcbda6c1a70606bdb09857e01d01fc6229da712/compiler/rustc_pattern_analysis/src/rustc.rs#L185-L194
The above function is called while trying to lint missing match arms, or scrutinize ctors of missing(not necessary error) match arms.
So, the following code can trigger ICEs.
```rust
trait WhereTrait {
type Type;
}
fn foo(e: Enum) {
match e {
Enum::Map(_) => (), // ICE, while trying to lint missing arms
}
if let Enum::Map(_) = e {} // ICE, while trying to scrutinize missing ctors (even worse)
}
enum Enum {
Map(()),
Map2(<() as WhereTrait>::Type),
}
```
This ICE won't be triggered with the following code, as this is filtered out before `check_match` as the existence of ill-formed type inside the variant marks the body as tainted by error in `hir_typeck`, but for the above code, the `hir_typeck` complains nothing because everything it sees is locally correct.
```rust
fn foo(e: Enum) {
match e {
Enum::Map2(_) => (), // No ICE
}
}
```
I've considered visiting and wf checking for the match scrutinee before entering `check_match`, but that might regress the perf and I think just emitting delayed bug would enough as the normalization failure would be originated by other errors like ill-formdness.
2 parents 1f2d7db + dae003b commit 17c25e4
3 files changed
Lines changed: 69 additions & 1 deletion
File tree
‎compiler/rustc_pattern_analysis/src/rustc.rs‎
Lines changed: 12 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -191,7 +191,18 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
191191
 variant.fields.iter().map(move |field| {
192192
let ty = field.ty(self.tcx, args);
193193
// `field.ty()` doesn't normalize after instantiating.
194-
let ty = self.tcx.normalize_erasing_regions(self.typing_env, ty);
194+
let ty =
195+
self.tcx.try_normalize_erasing_regions(self.typing_env, ty).unwrap_or_else(|e| {
196+
self.tcx.dcx().span_delayed_bug(
197+
self.scrut_span,
198+
format!(
199+
"Failed to normalize {:?} in typing_env={:?} while getting variant sub tys for {ty:?}",
200+
 e.get_type_for_failure(),
201+
self.typing_env,
202+
),
203+
);
204+
 ty
205+
});
195206
let ty = self.reveal_opaque_ty(ty);
196207
(field, ty)
197208
})
‎tests/ui/pattern/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs‎
Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
traitWhereTrait{
2+
typeType;
3+
}
4+
5+
fnfoo(e:Enum){
6+
ifletEnum::Map(_) = e {}
7+
8+
match e {
9+
//~^ ERROR: non-exhaustive patterns: `Enum::Map2(_)` not covered
10+
Enum::Map(_) => (),
11+
}
12+
}
13+
14+
enumEnum{
15+
Map(()),
16+
Map2(<()asWhereTrait>::Type),
17+
//~^ ERROR: the trait bound `(): WhereTrait` is not satisfied
18+
}
19+
20+
fnmain(){}
‎tests/ui/pattern/missing-ctor-with-ill-formed-inner-ty-issue-148192.stderr‎
Lines changed: 37 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
error[E0277]: the trait bound `(): WhereTrait` is not satisfied
2+
 --> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:16:10
3+
 |
4+
LL | Map2(<() as WhereTrait>::Type),
5+
 | ^^^^^^^^^^^^^^^^^^^^^^^^ the trait `WhereTrait` is not implemented for `()`
6+
 |
7+
help: this trait has no implementations, consider adding one
8+
 --> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:1:1
9+
 |
10+
LL | trait WhereTrait {
11+
 | ^^^^^^^^^^^^^^^^
12+
13+
error[E0004]: non-exhaustive patterns: `Enum::Map2(_)` not covered
14+
 --> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:8:11
15+
 |
16+
LL | match e {
17+
 | ^ pattern `Enum::Map2(_)` not covered
18+
 |
19+
note: `Enum` defined here
20+
 --> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:14:6
21+
 |
22+
LL | enum Enum {
23+
 | ^^^^
24+
LL | Map(()),
25+
LL | Map2(<() as WhereTrait>::Type),
26+
 | ---- not covered
27+
 = note: the matched value is of type `Enum`
28+
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
29+
 |
30+
LL ~ Enum::Map(_) => (),
31+
LL ~ Enum::Map2(_) => todo!(),
32+
 |
33+
34+
error: aborting due to 2 previous errors
35+
36+
Some errors have detailed explanations: E0004, E0277.
37+
For more information about an error, try `rustc --explain E0004`.
0 commit comments
Comments
 (0)

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
Commit 17c25e4
Browse files
ZalatharZalathar
authored
Rollup merge of #148872 - ShoyuVanilla:issue-148192, r=chenyukang
fix: Do not ICE when missing match arm with ill-formed subty is met
Fixes#148192
The ICE comes from the following line, calling `normalize_erasing_regions` to a projection type whose trait bound is not met:
https://github.com/rust-lang/rust/blob/2fcbda6c1a70606bdb09857e01d01fc6229da712/compiler/rustc_pattern_analysis/src/rustc.rs#L185-L194
The above function is called while trying to lint missing match arms, or scrutinize ctors of missing(not necessary error) match arms.
So, the following code can trigger ICEs.
```rust
trait WhereTrait {
type Type;
}
fn foo(e: Enum) {
match e {
Enum::Map(_) => (), // ICE, while trying to lint missing arms
}
if let Enum::Map(_) = e {} // ICE, while trying to scrutinize missing ctors (even worse)
}
enum Enum {
Map(()),
Map2(<() as WhereTrait>::Type),
}
```
This ICE won't be triggered with the following code, as this is filtered out before `check_match` as the existence of ill-formed type inside the variant marks the body as tainted by error in `hir_typeck`, but for the above code, the `hir_typeck` complains nothing because everything it sees is locally correct.
```rust
fn foo(e: Enum) {
match e {
Enum::Map2(_) => (), // No ICE
}
}
```
I've considered visiting and wf checking for the match scrutinee before entering `check_match`, but that might regress the perf and I think just emitting delayed bug would enough as the normalization failure would be originated by other errors like ill-formdness.
2 parents 1f2d7db + dae003b commit 17c25e4
3 files changed
Lines changed: 69 additions & 1 deletion
File tree
‎compiler/rustc_pattern_analysis/src/rustc.rs‎
Lines changed: 12 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -191,7 +191,18 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
191191
 variant.fields.iter().map(move |field| {
192192
let ty = field.ty(self.tcx, args);
193193
// `field.ty()` doesn't normalize after instantiating.
194-
let ty = self.tcx.normalize_erasing_regions(self.typing_env, ty);
194+
let ty =
195+
self.tcx.try_normalize_erasing_regions(self.typing_env, ty).unwrap_or_else(|e| {
196+
self.tcx.dcx().span_delayed_bug(
197+
self.scrut_span,
198+
format!(
199+
"Failed to normalize {:?} in typing_env={:?} while getting variant sub tys for {ty:?}",
200+
 e.get_type_for_failure(),
201+
self.typing_env,
202+
),
203+
);
204+
 ty
205+
});
195206
let ty = self.reveal_opaque_ty(ty);
196207
(field, ty)
197208
})
‎tests/ui/pattern/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs‎
Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
traitWhereTrait{
2+
typeType;
3+
}
4+
5+
fnfoo(e:Enum){
6+
ifletEnum::Map(_) = e {}
7+
8+
match e {
9+
//~^ ERROR: non-exhaustive patterns: `Enum::Map2(_)` not covered
10+
Enum::Map(_) => (),
11+
}
12+
}
13+
14+
enumEnum{
15+
Map(()),
16+
Map2(<()asWhereTrait>::Type),
17+
//~^ ERROR: the trait bound `(): WhereTrait` is not satisfied
18+
}
19+
20+
fnmain(){}
‎tests/ui/pattern/missing-ctor-with-ill-formed-inner-ty-issue-148192.stderr‎
Lines changed: 37 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
error[E0277]: the trait bound `(): WhereTrait` is not satisfied
2+
 --> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:16:10
3+
 |
4+
LL | Map2(<() as WhereTrait>::Type),
5+
 | ^^^^^^^^^^^^^^^^^^^^^^^^ the trait `WhereTrait` is not implemented for `()`
6+
 |
7+
help: this trait has no implementations, consider adding one
8+
 --> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:1:1
9+
 |
10+
LL | trait WhereTrait {
11+
 | ^^^^^^^^^^^^^^^^
12+
13+
error[E0004]: non-exhaustive patterns: `Enum::Map2(_)` not covered
14+
 --> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:8:11
15+
 |
16+
LL | match e {
17+
 | ^ pattern `Enum::Map2(_)` not covered
18+
 |
19+
note: `Enum` defined here
20+
 --> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:14:6
21+
 |
22+
LL | enum Enum {
23+
 | ^^^^
24+
LL | Map(()),
25+
LL | Map2(<() as WhereTrait>::Type),
26+
 | ---- not covered
27+
 = note: the matched value is of type `Enum`
28+
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
29+
 |
30+
LL ~ Enum::Map(_) => (),
31+
LL ~ Enum::Map2(_) => todo!(),
32+
 |
33+
34+
error: aborting due to 2 previous errors
35+
36+
Some errors have detailed explanations: E0004, E0277.
37+
For more information about an error, try `rustc --explain E0004`.
0 commit comments
Comments
 (0)

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
Commit 17c25e4
Browse files
ZalatharZalathar
authored
Rollup merge of #148872 - ShoyuVanilla:issue-148192, r=chenyukang
fix: Do not ICE when missing match arm with ill-formed subty is met
Fixes#148192
The ICE comes from the following line, calling `normalize_erasing_regions` to a projection type whose trait bound is not met:
https://github.com/rust-lang/rust/blob/2fcbda6c1a70606bdb09857e01d01fc6229da712/compiler/rustc_pattern_analysis/src/rustc.rs#L185-L194
The above function is called while trying to lint missing match arms, or scrutinize ctors of missing(not necessary error) match arms.
So, the following code can trigger ICEs.
```rust
trait WhereTrait {
type Type;
}
fn foo(e: Enum) {
match e {
Enum::Map(_) => (), // ICE, while trying to lint missing arms
}
if let Enum::Map(_) = e {} // ICE, while trying to scrutinize missing ctors (even worse)
}
enum Enum {
Map(()),
Map2(<() as WhereTrait>::Type),
}
```
This ICE won't be triggered with the following code, as this is filtered out before `check_match` as the existence of ill-formed type inside the variant marks the body as tainted by error in `hir_typeck`, but for the above code, the `hir_typeck` complains nothing because everything it sees is locally correct.
```rust
fn foo(e: Enum) {
match e {
Enum::Map2(_) => (), // No ICE
}
}
```
I've considered visiting and wf checking for the match scrutinee before entering `check_match`, but that might regress the perf and I think just emitting delayed bug would enough as the normalization failure would be originated by other errors like ill-formdness.
2 parents 1f2d7db + dae003b commit 17c25e4
3 files changed
Lines changed: 69 additions & 1 deletion
File tree
‎compiler/rustc_pattern_analysis/src/rustc.rs‎
Lines changed: 12 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -191,7 +191,18 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
191191
 variant.fields.iter().map(move |field| {
192192
let ty = field.ty(self.tcx, args);
193193
// `field.ty()` doesn't normalize after instantiating.
194-
let ty = self.tcx.normalize_erasing_regions(self.typing_env, ty);
194+
let ty =
195+
self.tcx.try_normalize_erasing_regions(self.typing_env, ty).unwrap_or_else(|e| {
196+
self.tcx.dcx().span_delayed_bug(
197+
self.scrut_span,
198+
format!(
199+
"Failed to normalize {:?} in typing_env={:?} while getting variant sub tys for {ty:?}",
200+
 e.get_type_for_failure(),
201+
self.typing_env,
202+
),
203+
);
204+
 ty
205+
});
195206
let ty = self.reveal_opaque_ty(ty);
196207
(field, ty)
197208
})
‎tests/ui/pattern/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs‎
Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
traitWhereTrait{
2+
typeType;
3+
}
4+
5+
fnfoo(e:Enum){
6+
ifletEnum::Map(_) = e {}
7+
8+
match e {
9+
//~^ ERROR: non-exhaustive patterns: `Enum::Map2(_)` not covered
10+
Enum::Map(_) => (),
11+
}
12+
}
13+
14+
enumEnum{
15+
Map(()),
16+
Map2(<()asWhereTrait>::Type),
17+
//~^ ERROR: the trait bound `(): WhereTrait` is not satisfied
18+
}
19+
20+
fnmain(){}
‎tests/ui/pattern/missing-ctor-with-ill-formed-inner-ty-issue-148192.stderr‎
Lines changed: 37 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
error[E0277]: the trait bound `(): WhereTrait` is not satisfied
2+
 --> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:16:10
3+
 |
4+
LL | Map2(<() as WhereTrait>::Type),
5+
 | ^^^^^^^^^^^^^^^^^^^^^^^^ the trait `WhereTrait` is not implemented for `()`
6+
 |
7+
help: this trait has no implementations, consider adding one
8+
 --> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:1:1
9+
 |
10+
LL | trait WhereTrait {
11+
 | ^^^^^^^^^^^^^^^^
12+
13+
error[E0004]: non-exhaustive patterns: `Enum::Map2(_)` not covered
14+
 --> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:8:11
15+
 |
16+
LL | match e {
17+
 | ^ pattern `Enum::Map2(_)` not covered
18+
 |
19+
note: `Enum` defined here
20+
 --> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:14:6
21+
 |
22+
LL | enum Enum {
23+
 | ^^^^
24+
LL | Map(()),
25+
LL | Map2(<() as WhereTrait>::Type),
26+
 | ---- not covered
27+
 = note: the matched value is of type `Enum`
28+
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
29+
 |
30+
LL ~ Enum::Map(_) => (),
31+
LL ~ Enum::Map2(_) => todo!(),
32+
 |
33+
34+
error: aborting due to 2 previous errors
35+
36+
Some errors have detailed explanations: E0004, E0277.
37+
For more information about an error, try `rustc --explain E0004`.
0 commit comments
Comments
 (0)

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
Commit 17c25e4
Browse files
ZalatharZalathar
authored
Rollup merge of #148872 - ShoyuVanilla:issue-148192, r=chenyukang
fix: Do not ICE when missing match arm with ill-formed subty is met
Fixes#148192
The ICE comes from the following line, calling `normalize_erasing_regions` to a projection type whose trait bound is not met:
https://github.com/rust-lang/rust/blob/2fcbda6c1a70606bdb09857e01d01fc6229da712/compiler/rustc_pattern_analysis/src/rustc.rs#L185-L194
The above function is called while trying to lint missing match arms, or scrutinize ctors of missing(not necessary error) match arms.
So, the following code can trigger ICEs.
```rust
trait WhereTrait {
type Type;
}
fn foo(e: Enum) {
match e {
Enum::Map(_) => (), // ICE, while trying to lint missing arms
}
if let Enum::Map(_) = e {} // ICE, while trying to scrutinize missing ctors (even worse)
}
enum Enum {
Map(()),
Map2(<() as WhereTrait>::Type),
}
```
This ICE won't be triggered with the following code, as this is filtered out before `check_match` as the existence of ill-formed type inside the variant marks the body as tainted by error in `hir_typeck`, but for the above code, the `hir_typeck` complains nothing because everything it sees is locally correct.
```rust
fn foo(e: Enum) {
match e {
Enum::Map2(_) => (), // No ICE
}
}
```
I've considered visiting and wf checking for the match scrutinee before entering `check_match`, but that might regress the perf and I think just emitting delayed bug would enough as the normalization failure would be originated by other errors like ill-formdness.
2 parents 1f2d7db + dae003b commit 17c25e4
3 files changed
Lines changed: 69 additions & 1 deletion
File tree
‎compiler/rustc_pattern_analysis/src/rustc.rs‎
Lines changed: 12 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -191,7 +191,18 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
191191
 variant.fields.iter().map(move |field| {
192192
let ty = field.ty(self.tcx, args);
193193
// `field.ty()` doesn't normalize after instantiating.
194-
let ty = self.tcx.normalize_erasing_regions(self.typing_env, ty);
194+
let ty =
195+
self.tcx.try_normalize_erasing_regions(self.typing_env, ty).unwrap_or_else(|e| {
196+
self.tcx.dcx().span_delayed_bug(
197+
self.scrut_span,
198+
format!(
199+
"Failed to normalize {:?} in typing_env={:?} while getting variant sub tys for {ty:?}",
200+
 e.get_type_for_failure(),
201+
self.typing_env,
202+
),
203+
);
204+
 ty
205+
});
195206
let ty = self.reveal_opaque_ty(ty);
196207
(field, ty)
197208
})
‎tests/ui/pattern/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs‎
Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
traitWhereTrait{
2+
typeType;
3+
}
4+
5+
fnfoo(e:Enum){
6+
ifletEnum::Map(_) = e {}
7+
8+
match e {
9+
//~^ ERROR: non-exhaustive patterns: `Enum::Map2(_)` not covered
10+
Enum::Map(_) => (),
11+
}
12+
}
13+
14+
enumEnum{
15+
Map(()),
16+
Map2(<()asWhereTrait>::Type),
17+
//~^ ERROR: the trait bound `(): WhereTrait` is not satisfied
18+
}
19+
20+
fnmain(){}
‎tests/ui/pattern/missing-ctor-with-ill-formed-inner-ty-issue-148192.stderr‎
Lines changed: 37 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
error[E0277]: the trait bound `(): WhereTrait` is not satisfied
2+
 --> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:16:10
3+
 |
4+
LL | Map2(<() as WhereTrait>::Type),
5+
 | ^^^^^^^^^^^^^^^^^^^^^^^^ the trait `WhereTrait` is not implemented for `()`
6+
 |
7+
help: this trait has no implementations, consider adding one
8+
 --> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:1:1
9+
 |
10+
LL | trait WhereTrait {
11+
 | ^^^^^^^^^^^^^^^^
12+
13+
error[E0004]: non-exhaustive patterns: `Enum::Map2(_)` not covered
14+
 --> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:8:11
15+
 |
16+
LL | match e {
17+
 | ^ pattern `Enum::Map2(_)` not covered
18+
 |
19+
note: `Enum` defined here
20+
 --> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:14:6
21+
 |
22+
LL | enum Enum {
23+
 | ^^^^
24+
LL | Map(()),
25+
LL | Map2(<() as WhereTrait>::Type),
26+
 | ---- not covered
27+
 = note: the matched value is of type `Enum`
28+
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
29+
 |
30+
LL ~ Enum::Map(_) => (),
31+
LL ~ Enum::Map2(_) => todo!(),
32+
 |
33+
34+
error: aborting due to 2 previous errors
35+
36+
Some errors have detailed explanations: E0004, E0277.
37+
For more information about an error, try `rustc --explain E0004`.
0 commit comments
Comments
 (0)

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
Commit 17c25e4
Browse files
ZalatharZalathar
authored
Rollup merge of #148872 - ShoyuVanilla:issue-148192, r=chenyukang
fix: Do not ICE when missing match arm with ill-formed subty is met
Fixes#148192
The ICE comes from the following line, calling `normalize_erasing_regions` to a projection type whose trait bound is not met:
https://github.com/rust-lang/rust/blob/2fcbda6c1a70606bdb09857e01d01fc6229da712/compiler/rustc_pattern_analysis/src/rustc.rs#L185-L194
The above function is called while trying to lint missing match arms, or scrutinize ctors of missing(not necessary error) match arms.
So, the following code can trigger ICEs.
```rust
trait WhereTrait {
type Type;
}
fn foo(e: Enum) {
match e {
Enum::Map(_) => (), // ICE, while trying to lint missing arms
}
if let Enum::Map(_) = e {} // ICE, while trying to scrutinize missing ctors (even worse)
}
enum Enum {
Map(()),
Map2(<() as WhereTrait>::Type),
}
```
This ICE won't be triggered with the following code, as this is filtered out before `check_match` as the existence of ill-formed type inside the variant marks the body as tainted by error in `hir_typeck`, but for the above code, the `hir_typeck` complains nothing because everything it sees is locally correct.
```rust
fn foo(e: Enum) {
match e {
Enum::Map2(_) => (), // No ICE
}
}
```
I've considered visiting and wf checking for the match scrutinee before entering `check_match`, but that might regress the perf and I think just emitting delayed bug would enough as the normalization failure would be originated by other errors like ill-formdness.
2 parents 1f2d7db + dae003b commit 17c25e4
3 files changed
Lines changed: 69 additions & 1 deletion
File tree
‎compiler/rustc_pattern_analysis/src/rustc.rs‎
Lines changed: 12 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -191,7 +191,18 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
191191
 variant.fields.iter().map(move |field| {
192192
let ty = field.ty(self.tcx, args);
193193
// `field.ty()` doesn't normalize after instantiating.
194-
let ty = self.tcx.normalize_erasing_regions(self.typing_env, ty);
194+
let ty =
195+
self.tcx.try_normalize_erasing_regions(self.typing_env, ty).unwrap_or_else(|e| {
196+
self.tcx.dcx().span_delayed_bug(
197+
self.scrut_span,
198+
format!(
199+
"Failed to normalize {:?} in typing_env={:?} while getting variant sub tys for {ty:?}",
200+
 e.get_type_for_failure(),
201+
self.typing_env,
202+
),
203+
);
204+
 ty
205+
});
195206
let ty = self.reveal_opaque_ty(ty);
196207
(field, ty)
197208
})
‎tests/ui/pattern/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs‎
Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
traitWhereTrait{
2+
typeType;
3+
}
4+
5+
fnfoo(e:Enum){
6+
ifletEnum::Map(_) = e {}
7+
8+
match e {
9+
//~^ ERROR: non-exhaustive patterns: `Enum::Map2(_)` not covered
10+
Enum::Map(_) => (),
11+
}
12+
}
13+
14+
enumEnum{
15+
Map(()),
16+
Map2(<()asWhereTrait>::Type),
17+
//~^ ERROR: the trait bound `(): WhereTrait` is not satisfied
18+
}
19+
20+
fnmain(){}
‎tests/ui/pattern/missing-ctor-with-ill-formed-inner-ty-issue-148192.stderr‎
Lines changed: 37 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
error[E0277]: the trait bound `(): WhereTrait` is not satisfied
2+
 --> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:16:10
3+
 |
4+
LL | Map2(<() as WhereTrait>::Type),
5+
 | ^^^^^^^^^^^^^^^^^^^^^^^^ the trait `WhereTrait` is not implemented for `()`
6+
 |
7+
help: this trait has no implementations, consider adding one
8+
 --> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:1:1
9+
 |
10+
LL | trait WhereTrait {
11+
 | ^^^^^^^^^^^^^^^^
12+
13+
error[E0004]: non-exhaustive patterns: `Enum::Map2(_)` not covered
14+
 --> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:8:11
15+
 |
16+
LL | match e {
17+
 | ^ pattern `Enum::Map2(_)` not covered
18+
 |
19+
note: `Enum` defined here
20+
 --> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:14:6
21+
 |
22+
LL | enum Enum {
23+
 | ^^^^
24+
LL | Map(()),
25+
LL | Map2(<() as WhereTrait>::Type),
26+
 | ---- not covered
27+
 = note: the matched value is of type `Enum`
28+
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
29+
 |
30+
LL ~ Enum::Map(_) => (),
31+
LL ~ Enum::Map2(_) => todo!(),
32+
 |
33+
34+
error: aborting due to 2 previous errors
35+
36+
Some errors have detailed explanations: E0004, E0277.
37+
For more information about an error, try `rustc --explain E0004`.
0 commit comments
Comments
 (0)

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
Commit 17c25e4
Browse files
ZalatharZalathar
authored
Rollup merge of #148872 - ShoyuVanilla:issue-148192, r=chenyukang
fix: Do not ICE when missing match arm with ill-formed subty is met
Fixes#148192
The ICE comes from the following line, calling `normalize_erasing_regions` to a projection type whose trait bound is not met:
https://github.com/rust-lang/rust/blob/2fcbda6c1a70606bdb09857e01d01fc6229da712/compiler/rustc_pattern_analysis/src/rustc.rs#L185-L194
The above function is called while trying to lint missing match arms, or scrutinize ctors of missing(not necessary error) match arms.
So, the following code can trigger ICEs.
```rust
trait WhereTrait {
type Type;
}
fn foo(e: Enum) {
match e {
Enum::Map(_) => (), // ICE, while trying to lint missing arms
}
if let Enum::Map(_) = e {} // ICE, while trying to scrutinize missing ctors (even worse)
}
enum Enum {
Map(()),
Map2(<() as WhereTrait>::Type),
}
```
This ICE won't be triggered with the following code, as this is filtered out before `check_match` as the existence of ill-formed type inside the variant marks the body as tainted by error in `hir_typeck`, but for the above code, the `hir_typeck` complains nothing because everything it sees is locally correct.
```rust
fn foo(e: Enum) {
match e {
Enum::Map2(_) => (), // No ICE
}
}
```
I've considered visiting and wf checking for the match scrutinee before entering `check_match`, but that might regress the perf and I think just emitting delayed bug would enough as the normalization failure would be originated by other errors like ill-formdness.
2 parents 1f2d7db + dae003b commit 17c25e4
3 files changed
Lines changed: 69 additions & 1 deletion
File tree
‎compiler/rustc_pattern_analysis/src/rustc.rs‎
Lines changed: 12 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -191,7 +191,18 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
191191
 variant.fields.iter().map(move |field| {
192192
let ty = field.ty(self.tcx, args);
193193
// `field.ty()` doesn't normalize after instantiating.
194-
let ty = self.tcx.normalize_erasing_regions(self.typing_env, ty);
194+
let ty =
195+
self.tcx.try_normalize_erasing_regions(self.typing_env, ty).unwrap_or_else(|e| {
196+
self.tcx.dcx().span_delayed_bug(
197+
self.scrut_span,
198+
format!(
199+
"Failed to normalize {:?} in typing_env={:?} while getting variant sub tys for {ty:?}",
200+
 e.get_type_for_failure(),
201+
self.typing_env,
202+
),
203+
);
204+
 ty
205+
});
195206
let ty = self.reveal_opaque_ty(ty);
196207
(field, ty)
197208
})
‎tests/ui/pattern/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs‎
Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
traitWhereTrait{
2+
typeType;
3+
}
4+
5+
fnfoo(e:Enum){
6+
ifletEnum::Map(_) = e {}
7+
8+
match e {
9+
//~^ ERROR: non-exhaustive patterns: `Enum::Map2(_)` not covered
10+
Enum::Map(_) => (),
11+
}
12+
}
13+
14+
enumEnum{
15+
Map(()),
16+
Map2(<()asWhereTrait>::Type),
17+
//~^ ERROR: the trait bound `(): WhereTrait` is not satisfied
18+
}
19+
20+
fnmain(){}
‎tests/ui/pattern/missing-ctor-with-ill-formed-inner-ty-issue-148192.stderr‎
Lines changed: 37 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
error[E0277]: the trait bound `(): WhereTrait` is not satisfied
2+
 --> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:16:10
3+
 |
4+
LL | Map2(<() as WhereTrait>::Type),
5+
 | ^^^^^^^^^^^^^^^^^^^^^^^^ the trait `WhereTrait` is not implemented for `()`
6+
 |
7+
help: this trait has no implementations, consider adding one
8+
 --> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:1:1
9+
 |
10+
LL | trait WhereTrait {
11+
 | ^^^^^^^^^^^^^^^^
12+
13+
error[E0004]: non-exhaustive patterns: `Enum::Map2(_)` not covered
14+
 --> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:8:11
15+
 |
16+
LL | match e {
17+
 | ^ pattern `Enum::Map2(_)` not covered
18+
 |
19+
note: `Enum` defined here
20+
 --> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:14:6
21+
 |
22+
LL | enum Enum {
23+
 | ^^^^
24+
LL | Map(()),
25+
LL | Map2(<() as WhereTrait>::Type),
26+
 | ---- not covered
27+
 = note: the matched value is of type `Enum`
28+
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
29+
 |
30+
LL ~ Enum::Map(_) => (),
31+
LL ~ Enum::Map2(_) => todo!(),
32+
 |
33+
34+
error: aborting due to 2 previous errors
35+
36+
Some errors have detailed explanations: E0004, E0277.
37+
For more information about an error, try `rustc --explain E0004`.
0 commit comments
Comments
 (0)

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
Commit 17c25e4
Browse files
ZalatharZalathar
authored
Rollup merge of #148872 - ShoyuVanilla:issue-148192, r=chenyukang
fix: Do not ICE when missing match arm with ill-formed subty is met
Fixes#148192
The ICE comes from the following line, calling `normalize_erasing_regions` to a projection type whose trait bound is not met:
https://github.com/rust-lang/rust/blob/2fcbda6c1a70606bdb09857e01d01fc6229da712/compiler/rustc_pattern_analysis/src/rustc.rs#L185-L194
The above function is called while trying to lint missing match arms, or scrutinize ctors of missing(not necessary error) match arms.
So, the following code can trigger ICEs.
```rust
trait WhereTrait {
type Type;
}
fn foo(e: Enum) {
match e {
Enum::Map(_) => (), // ICE, while trying to lint missing arms
}
if let Enum::Map(_) = e {} // ICE, while trying to scrutinize missing ctors (even worse)
}
enum Enum {
Map(()),
Map2(<() as WhereTrait>::Type),
}
```
This ICE won't be triggered with the following code, as this is filtered out before `check_match` as the existence of ill-formed type inside the variant marks the body as tainted by error in `hir_typeck`, but for the above code, the `hir_typeck` complains nothing because everything it sees is locally correct.
```rust
fn foo(e: Enum) {
match e {
Enum::Map2(_) => (), // No ICE
}
}
```
I've considered visiting and wf checking for the match scrutinee before entering `check_match`, but that might regress the perf and I think just emitting delayed bug would enough as the normalization failure would be originated by other errors like ill-formdness.
2 parents 1f2d7db + dae003b commit 17c25e4
3 files changed
Lines changed: 69 additions & 1 deletion
File tree
‎compiler/rustc_pattern_analysis/src/rustc.rs‎
Lines changed: 12 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -191,7 +191,18 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
191191
 variant.fields.iter().map(move |field| {
192192
let ty = field.ty(self.tcx, args);
193193
// `field.ty()` doesn't normalize after instantiating.
194-
let ty = self.tcx.normalize_erasing_regions(self.typing_env, ty);
194+
let ty =
195+
self.tcx.try_normalize_erasing_regions(self.typing_env, ty).unwrap_or_else(|e| {
196+
self.tcx.dcx().span_delayed_bug(
197+
self.scrut_span,
198+
format!(
199+
"Failed to normalize {:?} in typing_env={:?} while getting variant sub tys for {ty:?}",
200+
 e.get_type_for_failure(),
201+
self.typing_env,
202+
),
203+
);
204+
 ty
205+
});
195206
let ty = self.reveal_opaque_ty(ty);
196207
(field, ty)
197208
})
‎tests/ui/pattern/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs‎
Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
traitWhereTrait{
2+
typeType;
3+
}
4+
5+
fnfoo(e:Enum){
6+
ifletEnum::Map(_) = e {}
7+
8+
match e {
9+
//~^ ERROR: non-exhaustive patterns: `Enum::Map2(_)` not covered
10+
Enum::Map(_) => (),
11+
}
12+
}
13+
14+
enumEnum{
15+
Map(()),
16+
Map2(<()asWhereTrait>::Type),
17+
//~^ ERROR: the trait bound `(): WhereTrait` is not satisfied
18+
}
19+
20+
fnmain(){}
‎tests/ui/pattern/missing-ctor-with-ill-formed-inner-ty-issue-148192.stderr‎
Lines changed: 37 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
error[E0277]: the trait bound `(): WhereTrait` is not satisfied
2+
 --> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:16:10
3+
 |
4+
LL | Map2(<() as WhereTrait>::Type),
5+
 | ^^^^^^^^^^^^^^^^^^^^^^^^ the trait `WhereTrait` is not implemented for `()`
6+
 |
7+
help: this trait has no implementations, consider adding one
8+
 --> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:1:1
9+
 |
10+
LL | trait WhereTrait {
11+
 | ^^^^^^^^^^^^^^^^
12+
13+
error[E0004]: non-exhaustive patterns: `Enum::Map2(_)` not covered
14+
 --> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:8:11
15+
 |
16+
LL | match e {
17+
 | ^ pattern `Enum::Map2(_)` not covered
18+
 |
19+
note: `Enum` defined here
20+
 --> $DIR/missing-ctor-with-ill-formed-inner-ty-issue-148192.rs:14:6
21+
 |
22+
LL | enum Enum {
23+
 | ^^^^
24+
LL | Map(()),
25+
LL | Map2(<() as WhereTrait>::Type),
26+
 | ---- not covered
27+
 = note: the matched value is of type `Enum`
28+
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
29+
 |
30+
LL ~ Enum::Map(_) => (),
31+
LL ~ Enum::Map2(_) => todo!(),
32+
 |
33+
34+
error: aborting due to 2 previous errors
35+
36+
Some errors have detailed explanations: E0004, E0277.
37+
For more information about an error, try `rustc --explain E0004`.
0 commit comments
Comments
 (0)