MGCA: require #[type_const] on free consts too

khyperia · khyperia · commit 63e10454c0e3 · 2026-02-04T19:59:26.000+01:00
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -2669,6 +2669,15 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 self.lower_const_param(def_id, hir_id)
             }
             Res::Def(DefKind::Const, did) => {
+                if !find_attr!(self.tcx().get_all_attrs(did), AttributeKind::TypeConst(_)) {
+                    let mut err = self.dcx().struct_span_err(
+                        span,
+                        "use of `const` in the type system without `#[type_const]`",
+                    );
+                    err.note("the declaration must be marked with `#[type_const]`");
+                    return Const::new_error(self.tcx(), err.emit());
+                }
+
                 assert_eq!(opt_self_ty, None);
                 let [leading_segments @ .., segment] = path.segments else { bug!() };
                 let _ = self
diff --git a/tests/ui/const-generics/generic_const_exprs/auxiliary/non_local_type_const.rs b/tests/ui/const-generics/generic_const_exprs/auxiliary/non_local_type_const.rs
@@ -0,0 +1,5 @@
+#![feature(min_generic_const_args)]
+#![allow(incomplete_features)]
+
+#[type_const]
+pub const NON_LOCAL_CONST: char = 'a';
diff --git a/tests/ui/const-generics/generic_const_exprs/non-local-const.rs b/tests/ui/const-generics/generic_const_exprs/non-local-const.rs
@@ -1,10 +1,12 @@
 // regression test for #133808.
+//@ aux-build:non_local_type_const.rs
 
 #![feature(generic_const_exprs)]
 #![feature(min_generic_const_args)]
 #![allow(incomplete_features)]
 #![crate_type = "lib"]
+extern crate non_local_type_const;
 
 pub trait Foo {}
-impl Foo for [u8; std::path::MAIN_SEPARATOR] {}
-//~^ ERROR the constant `MAIN_SEPARATOR` is not of type `usize`
+impl Foo for [u8; non_local_type_const::NON_LOCAL_CONST] {}
+//~^ ERROR the constant `'a'` is not of type `usize`
diff --git a/tests/ui/const-generics/generic_const_exprs/non-local-const.stderr b/tests/ui/const-generics/generic_const_exprs/non-local-const.stderr
@@ -1,10 +1,10 @@
-error: the constant `MAIN_SEPARATOR` is not of type `usize`
-  --> $DIR/non-local-const.rs:9:14
+error: the constant `'a'` is not of type `usize`
+  --> $DIR/non-local-const.rs:11:14
    |
-LL | impl Foo for [u8; std::path::MAIN_SEPARATOR] {}
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `usize`, found `char`
+LL | impl Foo for [u8; non_local_type_const::NON_LOCAL_CONST] {}
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `usize`, found `char`
    |
-   = note: the length of array `[u8; MAIN_SEPARATOR]` must be type `usize`
+   = note: the length of array `[u8; 'a']` must be type `usize`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/mgca/const-arg-coherence-conflicting-methods.rs b/tests/ui/const-generics/mgca/const-arg-coherence-conflicting-methods.rs
@@ -3,6 +3,7 @@
 #![expect(incomplete_features)]
 #![feature(min_generic_const_args)]
 
+#[type_const]
 const C: usize = 0;
 pub struct A<const M: usize> {}
 impl A<C> {
diff --git a/tests/ui/const-generics/mgca/const-arg-coherence-conflicting-methods.stderr b/tests/ui/const-generics/mgca/const-arg-coherence-conflicting-methods.stderr
@@ -1,11 +1,11 @@
 error[E0107]: missing generics for struct `A`
-  --> $DIR/const-arg-coherence-conflicting-methods.rs:12:6
+  --> $DIR/const-arg-coherence-conflicting-methods.rs:13:6
    |
 LL | impl A {
    |      ^ expected 1 generic argument
    |
 note: struct defined here, with 1 generic parameter: `M`
-  --> $DIR/const-arg-coherence-conflicting-methods.rs:7:12
+  --> $DIR/const-arg-coherence-conflicting-methods.rs:8:12
    |
 LL | pub struct A<const M: usize> {}
    |            ^ --------------
@@ -15,7 +15,7 @@ LL | impl A<M> {
    |       +++
 
 error[E0592]: duplicate definitions with name `fun1`
-  --> $DIR/const-arg-coherence-conflicting-methods.rs:9:5
+  --> $DIR/const-arg-coherence-conflicting-methods.rs:10:5
    |
 LL |     fn fun1() {}
    |     ^^^^^^^^^ duplicate definitions for `fun1`
diff --git a/tests/ui/const-generics/mgca/tuple_ctor_erroneous.rs b/tests/ui/const-generics/mgca/tuple_ctor_erroneous.rs
@@ -12,6 +12,7 @@ enum MyEnum<T> {
     Unit,
 }
 
+#[type_const]
 const CONST_ITEM: u32 = 42;
 
 fn accepts_point<const P: Point>() {}
diff --git a/tests/ui/const-generics/mgca/tuple_ctor_erroneous.stderr b/tests/ui/const-generics/mgca/tuple_ctor_erroneous.stderr
@@ -1,5 +1,5 @@
 error[E0425]: cannot find function, tuple struct or tuple variant `UnresolvedIdent` in this scope
-  --> $DIR/tuple_ctor_erroneous.rs:29:23
+  --> $DIR/tuple_ctor_erroneous.rs:30:23
    |
 LL |     accepts_point::<{ UnresolvedIdent(N, N) }>();
    |                       ^^^^^^^^^^^^^^^ not found in this scope
@@ -10,55 +10,55 @@ LL | fn test_errors<const N: usize, const UnresolvedIdent: /* Type */>() {
    |                              +++++++++++++++++++++++++++++++++++
 
 error: tuple constructor has 2 arguments but 1 were provided
-  --> $DIR/tuple_ctor_erroneous.rs:23:23
+  --> $DIR/tuple_ctor_erroneous.rs:24:23
    |
 LL |     accepts_point::<{ Point(N) }>();
    |                       ^^^^^^^^
 
 error: tuple constructor has 2 arguments but 3 were provided
-  --> $DIR/tuple_ctor_erroneous.rs:26:23
+  --> $DIR/tuple_ctor_erroneous.rs:27:23
    |
 LL |     accepts_point::<{ Point(N, N, N) }>();
    |                       ^^^^^^^^^^^^^^
 
 error: tuple constructor with invalid base path
-  --> $DIR/tuple_ctor_erroneous.rs:29:23
+  --> $DIR/tuple_ctor_erroneous.rs:30:23
    |
 LL |     accepts_point::<{ UnresolvedIdent(N, N) }>();
    |                       ^^^^^^^^^^^^^^^^^^^^^
 
 error: tuple constructor with invalid base path
-  --> $DIR/tuple_ctor_erroneous.rs:33:23
+  --> $DIR/tuple_ctor_erroneous.rs:34:23
    |
 LL |     accepts_point::<{ non_ctor(N, N) }>();
    |                       ^^^^^^^^^^^^^^
 
 error: tuple constructor with invalid base path
-  --> $DIR/tuple_ctor_erroneous.rs:36:23
+  --> $DIR/tuple_ctor_erroneous.rs:37:23
    |
 LL |     accepts_point::<{ CONST_ITEM(N, N) }>();
    |                       ^^^^^^^^^^^^^^^^
 
 error: the constant `Point` is not of type `Point`
-  --> $DIR/tuple_ctor_erroneous.rs:39:23
+  --> $DIR/tuple_ctor_erroneous.rs:40:23
    |
 LL |     accepts_point::<{ Point }>();
    |                       ^^^^^ expected `Point`, found struct constructor
    |
 note: required by a const generic parameter in `accepts_point`
-  --> $DIR/tuple_ctor_erroneous.rs:17:18
+  --> $DIR/tuple_ctor_erroneous.rs:18:18
    |
 LL | fn accepts_point<const P: Point>() {}
    |                  ^^^^^^^^^^^^^^ required by this const generic parameter in `accepts_point`
 
 error: the constant `MyEnum::<u32>::Variant` is not of type `MyEnum<u32>`
-  --> $DIR/tuple_ctor_erroneous.rs:42:22
+  --> $DIR/tuple_ctor_erroneous.rs:43:22
    |
 LL |     accepts_enum::<{ MyEnum::Variant::<u32> }>();
    |                      ^^^^^^^^^^^^^^^^^^^^^^ expected `MyEnum<u32>`, found enum constructor
    |
 note: required by a const generic parameter in `accepts_enum`
-  --> $DIR/tuple_ctor_erroneous.rs:18:17
+  --> $DIR/tuple_ctor_erroneous.rs:19:17
    |
 LL | fn accepts_enum<const E: MyEnum<u32>>() {}
    |                 ^^^^^^^^^^^^^^^^^^^^ required by this const generic parameter in `accepts_enum`
diff --git a/tests/ui/const-generics/mgca/unmarked-free-const.rs b/tests/ui/const-generics/mgca/unmarked-free-const.rs
@@ -0,0 +1,11 @@
+// regression test, used to ICE
+
+#![feature(min_generic_const_args)]
+#![allow(incomplete_features)]
+
+const N: usize = 4;
+
+fn main() {
+    let x = [(); N];
+    //~^ ERROR use of `const` in the type system without `#[type_const]`
+}
diff --git a/tests/ui/const-generics/mgca/unmarked-free-const.stderr b/tests/ui/const-generics/mgca/unmarked-free-const.stderr
@@ -0,0 +1,10 @@
+error: use of `const` in the type system without `#[type_const]`
+  --> $DIR/unmarked-free-const.rs:9:18
+   |
+LL |     let x = [(); N];
+   |                  ^
+   |
+   = note: the declaration must be marked with `#[type_const]`
+
+error: aborting due to 1 previous error
+

Original file line number	Diff line number	Diff line change
`@@ -1,10 +1,10 @@`
`1`		-error: the constant `MAIN_SEPARATOR` is not of type `usize`
`2`		`- --> $DIR/non-local-const.rs:9:14`
	`1`	+error: the constant `'a'` is not of type `usize`
	`2`	`+ --> $DIR/non-local-const.rs:11:14`
`3`	`3`	`\|`
`4`		`-LL \| impl Foo for [u8; std::path::MAIN_SEPARATOR] {}`
`5`		- \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `usize`, found `char`
	`4`	`+LL \| impl Foo for [u8; non_local_type_const::NON_LOCAL_CONST] {}`
	`5`	+ \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `usize`, found `char`
`6`	`6`	`\|`
`7`		- = note: the length of array `[u8; MAIN_SEPARATOR]` must be type `usize`
	`7`	+ = note: the length of array `[u8; 'a']` must be type `usize`
`8`	`8`
`9`	`9`	`error: aborting due to 1 previous error`
`10`	`10`
Original file line number	Diff line number	Diff line change
`@@ -1,11 +1,11 @@`
`1`	`1`	error[E0107]: missing generics for struct `A`
`2`		`- --> $DIR/const-arg-coherence-conflicting-methods.rs:12:6`
	`2`	`+ --> $DIR/const-arg-coherence-conflicting-methods.rs:13:6`
`3`	`3`	`\|`
`4`	`4`	`LL \| impl A {`
`5`	`5`	`\| ^ expected 1 generic argument`
`6`	`6`	`\|`
`7`	`7`	note: struct defined here, with 1 generic parameter: `M`
`8`		`- --> $DIR/const-arg-coherence-conflicting-methods.rs:7:12`
	`8`	`+ --> $DIR/const-arg-coherence-conflicting-methods.rs:8:12`
`9`	`9`	`\|`
`10`	`10`	`LL \| pub struct A<const M: usize> {}`
`11`	`11`	`\| ^ --------------`
`@@ -15,7 +15,7 @@ LL \| impl A<M> {`
`15`	`15`	`\| +++`
`16`	`16`
`17`	`17`	error[E0592]: duplicate definitions with name `fun1`
`18`		`- --> $DIR/const-arg-coherence-conflicting-methods.rs:9:5`
	`18`	`+ --> $DIR/const-arg-coherence-conflicting-methods.rs:10:5`
`19`	`19`	`\|`
`20`	`20`	`LL \| fn fun1() {}`
`21`	`21`	\| ^^^^^^^^^ duplicate definitions for `fun1`
Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,7 @@ enum MyEnum<T> {`
`12`	`12`	`Unit,`
`13`	`13`	`}`
`14`	`14`
	`15`	`+#[type_const]`
`15`	`16`	`const CONST_ITEM: u32 = 42;`
`16`	`17`
`17`	`18`	`fn accepts_point<const P: Point>() {}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	error[E0425]: cannot find function, tuple struct or tuple variant `UnresolvedIdent` in this scope
`2`		`- --> $DIR/tuple_ctor_erroneous.rs:29:23`
	`2`	`+ --> $DIR/tuple_ctor_erroneous.rs:30:23`
`3`	`3`	`\|`
`4`	`4`	`LL \| accepts_point::<{ UnresolvedIdent(N, N) }>();`
`5`	`5`	`\| ^^^^^^^^^^^^^^^ not found in this scope`
`@@ -10,55 +10,55 @@ LL \| fn test_errors<const N: usize, const UnresolvedIdent: /* Type */>() {`
`10`	`10`	`\| +++++++++++++++++++++++++++++++++++`
`11`	`11`
`12`	`12`	`error: tuple constructor has 2 arguments but 1 were provided`
`13`		`- --> $DIR/tuple_ctor_erroneous.rs:23:23`
	`13`	`+ --> $DIR/tuple_ctor_erroneous.rs:24:23`
`14`	`14`	`\|`
`15`	`15`	`LL \| accepts_point::<{ Point(N) }>();`
`16`	`16`	`\| ^^^^^^^^`
`17`	`17`
`18`	`18`	`error: tuple constructor has 2 arguments but 3 were provided`
`19`		`- --> $DIR/tuple_ctor_erroneous.rs:26:23`
	`19`	`+ --> $DIR/tuple_ctor_erroneous.rs:27:23`
`20`	`20`	`\|`
`21`	`21`	`LL \| accepts_point::<{ Point(N, N, N) }>();`
`22`	`22`	`\| ^^^^^^^^^^^^^^`
`23`	`23`
`24`	`24`	`error: tuple constructor with invalid base path`
`25`		`- --> $DIR/tuple_ctor_erroneous.rs:29:23`
	`25`	`+ --> $DIR/tuple_ctor_erroneous.rs:30:23`
`26`	`26`	`\|`
`27`	`27`	`LL \| accepts_point::<{ UnresolvedIdent(N, N) }>();`
`28`	`28`	`\| ^^^^^^^^^^^^^^^^^^^^^`
`29`	`29`
`30`	`30`	`error: tuple constructor with invalid base path`
`31`		`- --> $DIR/tuple_ctor_erroneous.rs:33:23`
	`31`	`+ --> $DIR/tuple_ctor_erroneous.rs:34:23`
`32`	`32`	`\|`
`33`	`33`	`LL \| accepts_point::<{ non_ctor(N, N) }>();`
`34`	`34`	`\| ^^^^^^^^^^^^^^`
`35`	`35`
`36`	`36`	`error: tuple constructor with invalid base path`
`37`		`- --> $DIR/tuple_ctor_erroneous.rs:36:23`
	`37`	`+ --> $DIR/tuple_ctor_erroneous.rs:37:23`
`38`	`38`	`\|`
`39`	`39`	`LL \| accepts_point::<{ CONST_ITEM(N, N) }>();`
`40`	`40`	`\| ^^^^^^^^^^^^^^^^`
`41`	`41`
`42`	`42`	error: the constant `Point` is not of type `Point`
`43`		`- --> $DIR/tuple_ctor_erroneous.rs:39:23`
	`43`	`+ --> $DIR/tuple_ctor_erroneous.rs:40:23`
`44`	`44`	`\|`
`45`	`45`	`LL \| accepts_point::<{ Point }>();`
`46`	`46`	\| ^^^^^ expected `Point`, found struct constructor
`47`	`47`	`\|`
`48`	`48`	note: required by a const generic parameter in `accepts_point`
`49`		`- --> $DIR/tuple_ctor_erroneous.rs:17:18`
	`49`	`+ --> $DIR/tuple_ctor_erroneous.rs:18:18`
`50`	`50`	`\|`
`51`	`51`	`LL \| fn accepts_point<const P: Point>() {}`
`52`	`52`	\| ^^^^^^^^^^^^^^ required by this const generic parameter in `accepts_point`
`53`	`53`
`54`	`54`	error: the constant `MyEnum::<u32>::Variant` is not of type `MyEnum<u32>`
`55`		`- --> $DIR/tuple_ctor_erroneous.rs:42:22`
	`55`	`+ --> $DIR/tuple_ctor_erroneous.rs:43:22`
`56`	`56`	`\|`
`57`	`57`	`LL \| accepts_enum::<{ MyEnum::Variant::<u32> }>();`
`58`	`58`	\| ^^^^^^^^^^^^^^^^^^^^^^ expected `MyEnum<u32>`, found enum constructor
`59`	`59`	`\|`
`60`	`60`	note: required by a const generic parameter in `accepts_enum`
`61`		`- --> $DIR/tuple_ctor_erroneous.rs:18:17`
	`61`	`+ --> $DIR/tuple_ctor_erroneous.rs:19:17`
`62`	`62`	`\|`
`63`	`63`	`LL \| fn accepts_enum<const E: MyEnum<u32>>() {}`
`64`	`64`	\| ^^^^^^^^^^^^^^^^^^^^ required by this const generic parameter in `accepts_enum`