Skip to content

Commit 204a156

Browse files
HKalbasiHKalbasi
committed
consider types of const generics
1 parent 5ac07a8 commit 204a156

File tree

6 files changed

+86
-56
lines changed

6 files changed

+86
-56
lines changed

‎crates/hir_ty/src/builder.rs

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -154,6 +154,10 @@ impl TyBuilder<()> {
154154
TyKind::Tuple(0, Substitution::empty(Interner)).intern(Interner)
155155
}
156156

157+
pub fn usize() -> Ty {
158+
TyKind::Scalar(chalk_ir::Scalar::Uint(chalk_ir::UintTy::Usize)).intern(Interner)
159+
}
160+
157161
pub fn fn_ptr(sig: CallableSig) -> Ty {
158162
TyKind::Function(sig.to_fn_ptr()).intern(Interner)
159163
}

‎crates/hir_ty/src/consteval.rs

Lines changed: 11 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@ use stdx::never;
2020
use crate::{
2121
db::HirDatabase, infer::InferenceContext, lower::ParamLoweringMode, to_placeholder_idx,
2222
utils::Generics, Const, ConstData, ConstValue, GenericArg, InferenceResult, Interner, Ty,
23-
TyKind,
23+
TyBuilder, TyKind,
2424
};
2525

2626
/// Extension trait for [`Const`]
@@ -401,23 +401,22 @@ pub fn unknown_const(ty: Ty) -> Const {
401401
.intern(Interner)
402402
}
403403

404-
pub fn unknown_const_usize() -> Const {
405-
unknown_const(TyKind::Scalar(chalk_ir::Scalar::Uint(chalk_ir::UintTy::Usize)).intern(Interner))
406-
}
407-
408404
pub fn unknown_const_as_generic(ty: Ty) -> GenericArg {
409405
GenericArgData::Const(unknown_const(ty)).intern(Interner)
410406
}
411407

408+
/// Interns a constant scalar with the given type
409+
pub fn intern_scalar_const(value: ConstScalar, ty: Ty) -> Const {
410+
ConstData { ty, value: ConstValue::Concrete(chalk_ir::ConcreteConst { interned: value }) }
411+
.intern(Interner)
412+
}
413+
412414
/// Interns a possibly-unknown target usize
413415
pub fn usize_const(value: Option<u64>) -> Const {
414-
ConstData {
415-
ty: TyKind::Scalar(chalk_ir::Scalar::Uint(chalk_ir::UintTy::Usize)).intern(Interner),
416-
value: ConstValue::Concrete(chalk_ir::ConcreteConst {
417-
interned: value.map(ConstScalar::Usize).unwrap_or(ConstScalar::Unknown),
418-
}),
419-
}
420-
.intern(Interner)
416+
intern_scalar_const(
417+
value.map(ConstScalar::Usize).unwrap_or(ConstScalar::Unknown),
418+
TyBuilder::usize(),
419+
)
421420
}
422421

423422
pub(crate) fn const_eval_recover(

‎crates/hir_ty/src/infer/expr.rs

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1129,10 +1129,11 @@ impl<'a> InferenceContext<'a> {
11291129
arg,
11301130
self,
11311131
|this, type_ref| this.make_ty(type_ref),
1132-
|this, c| {
1132+
|this, c, ty| {
11331133
const_or_path_to_chalk(
11341134
this.db,
11351135
&this.resolver,
1136+
ty,
11361137
c,
11371138
ParamLoweringMode::Placeholder,
11381139
|| generics(this.db.upcast(), (&this.resolver).generic_def().unwrap()),

‎crates/hir_ty/src/lib.rs

Lines changed: 7 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -35,17 +35,13 @@ use std::sync::Arc;
3535
use chalk_ir::{
3636
fold::{Fold, Shift},
3737
interner::HasInterner,
38-
NoSolution, UintTy,
39-
};
40-
use hir_def::{
41-
expr::ExprId,
42-
type_ref::{ConstScalar, Rawness},
43-
TypeOrConstParamId,
38+
NoSolution,
4439
};
40+
use hir_def::{expr::ExprId, type_ref::Rawness, TypeOrConstParamId};
4541
use itertools::Either;
4642
use utils::Generics;
4743

48-
use crate::{db::HirDatabase, utils::generics};
44+
use crate::{consteval::unknown_const, db::HirDatabase, utils::generics};
4945

5046
pub use autoderef::autoderef;
5147
pub use builder::{ParamKind, TyBuilder};
@@ -303,17 +299,6 @@ pub fn static_lifetime() -> Lifetime {
303299
LifetimeData::Static.intern(Interner)
304300
}
305301

306-
pub fn dummy_usize_const() -> Const {
307-
let usize_ty = chalk_ir::TyKind::Scalar(Scalar::Uint(UintTy::Usize)).intern(Interner);
308-
chalk_ir::ConstData {
309-
ty: usize_ty,
310-
value: chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst {
311-
interned: ConstScalar::Unknown,
312-
}),
313-
}
314-
.intern(Interner)
315-
}
316-
317302
pub(crate) fn fold_free_vars<T: HasInterner<Interner = Interner> + Fold<Interner>>(
318303
t: T,
319304
for_ty: impl FnMut(BoundVar, DebruijnIndex) -> Ty,
@@ -476,27 +461,27 @@ where
476461

477462
fn fold_inference_const(
478463
&mut self,
479-
_ty: Ty,
464+
ty: Ty,
480465
_var: InferenceVar,
481466
_outer_binder: DebruijnIndex,
482467
) -> Fallible<Const> {
483468
if cfg!(debug_assertions) {
484469
Err(NoSolution)
485470
} else {
486-
Ok(dummy_usize_const())
471+
Ok(unknown_const(ty))
487472
}
488473
}
489474

490475
fn fold_free_var_const(
491476
&mut self,
492-
_ty: Ty,
477+
ty: Ty,
493478
_bound_var: BoundVar,
494479
_outer_binder: DebruijnIndex,
495480
) -> Fallible<Const> {
496481
if cfg!(debug_assertions) {
497482
Err(NoSolution)
498483
} else {
499-
Ok(dummy_usize_const())
484+
Ok(unknown_const(ty))
500485
}
501486
}
502487

‎crates/hir_ty/src/lower.rs

Lines changed: 30 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -37,11 +37,12 @@ use smallvec::SmallVec;
3737
use stdx::{impl_from, never};
3838
use syntax::{ast, SmolStr};
3939

40-
use crate::consteval::{path_to_const, unknown_const_as_generic, unknown_const_usize, usize_const};
40+
use crate::consteval::{
41+
intern_scalar_const, path_to_const, unknown_const, unknown_const_as_generic,
42+
};
4143
use crate::utils::Generics;
4244
use crate::{all_super_traits, make_binders, Const, GenericArgData, ParamKind};
4345
use crate::{
44-
consteval,
4546
db::HirDatabase,
4647
mapping::ToChalk,
4748
static_lifetime, to_assoc_type_id, to_chalk_trait_id, to_placeholder_idx,
@@ -202,6 +203,7 @@ impl<'a> TyLoweringContext<'a> {
202203
let const_len = const_or_path_to_chalk(
203204
self.db,
204205
self.resolver,
206+
TyBuilder::usize(),
205207
len,
206208
self.type_param_mode,
207209
|| self.generics(),
@@ -677,12 +679,13 @@ impl<'a> TyLoweringContext<'a> {
677679
parent_params + self_params + type_params + const_params + impl_trait_params;
678680

679681
let ty_error = GenericArgData::Ty(TyKind::Error.intern(Interner)).intern(Interner);
680-
let const_error = GenericArgData::Const(consteval::usize_const(None)).intern(Interner);
681682

682-
for (_, data) in def_generics.iter().take(parent_params) {
683-
match data {
684-
TypeOrConstParamData::TypeParamData(_) => substs.push(ty_error.clone()),
685-
TypeOrConstParamData::ConstParamData(_) => substs.push(const_error.clone()),
683+
for eid in def_generics.iter_id().take(parent_params) {
684+
match eid {
685+
Either::Left(_) => substs.push(ty_error.clone()),
686+
Either::Right(x) => {
687+
substs.push(unknown_const_as_generic(self.db.const_param_ty(x)))
688+
}
686689
}
687690
}
688691

@@ -722,10 +725,11 @@ impl<'a> TyLoweringContext<'a> {
722725
arg,
723726
&mut (),
724727
|_, type_ref| self.lower_ty(type_ref),
725-
|_, c| {
728+
|_, c, ty| {
726729
const_or_path_to_chalk(
727730
self.db,
728731
&self.resolver,
732+
ty,
729733
c,
730734
self.type_param_mode,
731735
|| self.generics(),
@@ -759,10 +763,12 @@ impl<'a> TyLoweringContext<'a> {
759763

760764
// add placeholders for args that were not provided
761765
// FIXME: emit diagnostics in contexts where this is not allowed
762-
for (_, data) in def_generics.iter().skip(substs.len()) {
763-
match data {
764-
TypeOrConstParamData::TypeParamData(_) => substs.push(ty_error.clone()),
765-
TypeOrConstParamData::ConstParamData(_) => substs.push(const_error.clone()),
766+
for eid in def_generics.iter_id().skip(substs.len()) {
767+
match eid {
768+
Either::Left(_) => substs.push(ty_error.clone()),
769+
Either::Right(x) => {
770+
substs.push(unknown_const_as_generic(self.db.const_param_ty(x)))
771+
}
766772
}
767773
}
768774
assert_eq!(substs.len(), total_len);
@@ -1642,7 +1648,7 @@ pub(crate) fn generic_arg_to_chalk<'a, T>(
16421648
arg: &'a GenericArg,
16431649
this: &mut T,
16441650
for_type: impl FnOnce(&mut T, &TypeRef) -> Ty + 'a,
1645-
for_const: impl FnOnce(&mut T, &ConstScalarOrPath) -> Const + 'a,
1651+
for_const: impl FnOnce(&mut T, &ConstScalarOrPath, Ty) -> Const + 'a,
16461652
) -> Option<crate::GenericArg> {
16471653
let kind = match kind_id {
16481654
Either::Left(_) => ParamKind::Type,
@@ -1656,13 +1662,13 @@ pub(crate) fn generic_arg_to_chalk<'a, T>(
16561662
let ty = for_type(this, type_ref);
16571663
GenericArgData::Ty(ty).intern(Interner)
16581664
}
1659-
(GenericArg::Const(c), ParamKind::Const(_)) => {
1660-
GenericArgData::Const(for_const(this, c)).intern(Interner)
1665+
(GenericArg::Const(c), ParamKind::Const(c_ty)) => {
1666+
GenericArgData::Const(for_const(this, c, c_ty)).intern(Interner)
16611667
}
16621668
(GenericArg::Const(_), ParamKind::Type) => {
16631669
GenericArgData::Ty(TyKind::Error.intern(Interner)).intern(Interner)
16641670
}
1665-
(GenericArg::Type(t), ParamKind::Const(ty)) => {
1671+
(GenericArg::Type(t), ParamKind::Const(c_ty)) => {
16661672
// We want to recover simple idents, which parser detects them
16671673
// as types. Maybe here is not the best place to do it, but
16681674
// it works.
@@ -1671,11 +1677,13 @@ pub(crate) fn generic_arg_to_chalk<'a, T>(
16711677
if p.kind == PathKind::Plain {
16721678
if let [n] = p.segments() {
16731679
let c = ConstScalarOrPath::Path(n.clone());
1674-
return Some(GenericArgData::Const(for_const(this, &c)).intern(Interner));
1680+
return Some(
1681+
GenericArgData::Const(for_const(this, &c, c_ty)).intern(Interner),
1682+
);
16751683
}
16761684
}
16771685
}
1678-
unknown_const_as_generic(ty)
1686+
unknown_const_as_generic(c_ty)
16791687
}
16801688
(GenericArg::Lifetime(_), _) => return None,
16811689
})
@@ -1684,17 +1692,18 @@ pub(crate) fn generic_arg_to_chalk<'a, T>(
16841692
pub(crate) fn const_or_path_to_chalk(
16851693
db: &dyn HirDatabase,
16861694
resolver: &Resolver,
1695+
expected_ty: Ty,
16871696
value: &ConstScalarOrPath,
16881697
mode: ParamLoweringMode,
16891698
args: impl FnOnce() -> Generics,
16901699
debruijn: DebruijnIndex,
16911700
) -> Const {
16921701
match value {
1693-
ConstScalarOrPath::Scalar(s) => usize_const(s.as_usize()),
1702+
ConstScalarOrPath::Scalar(s) => intern_scalar_const(s.clone(), expected_ty),
16941703
ConstScalarOrPath::Path(n) => {
16951704
let path = ModPath::from_segments(PathKind::Plain, Some(n.clone()));
16961705
path_to_const(db, resolver, &path, mode, args, debruijn)
1697-
.unwrap_or_else(|| unknown_const_usize())
1706+
.unwrap_or_else(|| unknown_const(expected_ty))
16981707
}
16991708
}
17001709
}
@@ -1716,7 +1725,7 @@ fn fallback_bound_vars<T: Fold<Interner> + HasInterner<Interner = Interner>>(
17161725
},
17171726
|ty, bound, binders| {
17181727
if bound.index >= num_vars_to_keep && bound.debruijn == DebruijnIndex::INNERMOST {
1719-
consteval::unknown_const(ty.clone())
1728+
unknown_const(ty.clone())
17201729
} else {
17211730
bound.shifted_in_from(binders).to_const(Interner, ty)
17221731
}

‎crates/ide_diagnostics/src/handlers/type_mismatch.rs

Lines changed: 32 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -316,6 +316,38 @@ fn div(x: i32, y: i32) -> Option<i32> {
316316
);
317317
}
318318

319+
#[test]
320+
fn const_generic_type_mismatch() {
321+
check_diagnostics(
322+
r#"
323+
pub struct Rate<const N: u32>;
324+
fn f<const N: u64>() -> Rate<N> { // FIXME: add some error
325+
loop {}
326+
}
327+
fn run(t: Rate<5>) {
328+
}
329+
fn main() {
330+
run(f()) // FIXME: remove this error
331+
//^^^ error: expected Rate<5>, found Rate<_>
332+
}
333+
"#,
334+
);
335+
}
336+
337+
#[test]
338+
fn const_generic_unknown() {
339+
check_diagnostics(
340+
r#"
341+
pub struct Rate<T, const NOM: u32, const DENOM: u32>(T);
342+
fn run(t: Rate<u32, 1, 1>) {
343+
}
344+
fn main() {
345+
run(Rate::<_, _, _>(5));
346+
}
347+
"#,
348+
);
349+
}
350+
319351
#[test]
320352
fn test_wrap_return_type_option_tails() {
321353
check_fix(

0 commit comments

Comments
 (0)