rust-analyzer

diff --git a/crates/hir-ty/src/builder.rs b/crates/hir-ty/src/builder.rs
index eec57ba3f8..967e028bfb 100644
--- a/crates/hir-ty/src/builder.rs
+++ b/crates/hir-ty/src/builder.rs

@@ -17,7 +17,8 @@ use smallvec::SmallVec;

use crate::{

consteval::unknown_const_as_generic, db::HirDatabase, infer::unify::InferenceTable, primitive,

to_assoc_type_id, to_chalk_trait_id, utils::generics, Binders, BoundVar, CallableSig,

- GenericArg, Interner, ProjectionTy, Substitution, TraitRef, Ty, TyDefId, TyExt, TyKind,

+ GenericArg, GenericArgData, Interner, ProjectionTy, Substitution, TraitRef, Ty, TyDefId, TyExt,

+ TyKind,

};

#[derive(Debug, Clone, PartialEq, Eq)]

@@ -79,9 +80,9 @@ impl<D> TyBuilder<D> {

let expected_kind = &self.param_kinds[self.vec.len()];

let arg_kind = match arg.data(Interner) {

- chalk_ir::GenericArgData::Ty(_) => ParamKind::Type,

- chalk_ir::GenericArgData::Lifetime(_) => panic!("Got lifetime in TyBuilder::push"),

- chalk_ir::GenericArgData::Const(c) => {

+ GenericArgData::Ty(_) => ParamKind::Type,

+ GenericArgData::Lifetime(_) => panic!("Got lifetime in TyBuilder::push"),

+ GenericArgData::Const(c) => {

let c = c.data(Interner);

ParamKind::Const(c.ty.clone())

}

@@ -139,8 +140,8 @@ impl<D> TyBuilder<D> {

fn assert_match_kind(&self, a: &chalk_ir::GenericArg<Interner>, e: &ParamKind) {

match (a.data(Interner), e) {

- (chalk_ir::GenericArgData::Ty(_), ParamKind::Type)

- | (chalk_ir::GenericArgData::Const(_), ParamKind::Const(_)) => (),

+ (GenericArgData::Ty(_), ParamKind::Type)

+ | (GenericArgData::Const(_), ParamKind::Const(_)) => (),

_ => panic!("Mismatched kinds: {a:?}, {:?}, {:?}", self.vec, self.param_kinds),

}

diff --git a/crates/hir-ty/src/consteval.rs b/crates/hir-ty/src/consteval.rs
index 1c0f7b08da..0348680e5d 100644
--- a/crates/hir-ty/src/consteval.rs
+++ b/crates/hir-ty/src/consteval.rs

@@ -1,7 +1,7 @@

//! Constant evaluation details

use base_db::CrateId;

-use chalk_ir::{BoundVar, DebruijnIndex, GenericArgData};

+use chalk_ir::{cast::Cast, BoundVar, DebruijnIndex};

use hir_def::{

hir::Expr,

path::Path,

@@ -120,7 +120,7 @@ pub fn unknown_const(ty: Ty) -> Const {

}

pub fn unknown_const_as_generic(ty: Ty) -> GenericArg {

- GenericArgData::Const(unknown_const(ty)).intern(Interner)

+ unknown_const(ty).cast(Interner)

}

/// Interns a constant scalar with the given type

diff --git a/crates/hir-ty/src/infer/expr.rs b/crates/hir-ty/src/infer/expr.rs
index 8cbdae6252..8b35214108 100644
--- a/crates/hir-ty/src/infer/expr.rs
+++ b/crates/hir-ty/src/infer/expr.rs

@@ -5,9 +5,7 @@ use std::{

mem,

};

-use chalk_ir::{

- cast::Cast, fold::Shift, DebruijnIndex, GenericArgData, Mutability, TyVariableKind,

-};

+use chalk_ir::{cast::Cast, fold::Shift, DebruijnIndex, Mutability, TyVariableKind};

use hir_def::{

generics::TypeOrConstParamData,

hir::{

@@ -750,7 +748,7 @@ impl InferenceContext<'_> {

self.resolve_associated_type_with_params(

self_ty,

self.resolve_ops_index_output(),

- &[GenericArgData::Ty(index_ty).intern(Interner)],

+ &[index_ty.cast(Interner)],

)

} else {

self.err_ty()

@@ -1721,16 +1719,13 @@ impl InferenceContext<'_> {

for (id, data) in def_generics.iter().skip(substs.len()) {

match data {

TypeOrConstParamData::TypeParamData(_) => {

- substs.push(GenericArgData::Ty(self.table.new_type_var()).intern(Interner))

- }

- TypeOrConstParamData::ConstParamData(_) => {

- substs.push(

- GenericArgData::Const(self.table.new_const_var(

- self.db.const_param_ty(ConstParamId::from_unchecked(id)),

- ))

- .intern(Interner),

- )

+ substs.push(self.table.new_type_var().cast(Interner))

}

+ TypeOrConstParamData::ConstParamData(_) => substs.push(

+ self.table

+ .new_const_var(self.db.const_param_ty(ConstParamId::from_unchecked(id)))

+ .cast(Interner),

+ ),

}

assert_eq!(substs.len(), total_len);

diff --git a/crates/hir-ty/src/infer/unify.rs b/crates/hir-ty/src/infer/unify.rs
index 0fb71135b4..169679b463 100644
--- a/crates/hir-ty/src/infer/unify.rs
+++ b/crates/hir-ty/src/infer/unify.rs

@@ -10,7 +10,6 @@ use chalk_solve::infer::ParameterEnaVariableExt;

use either::Either;

use ena::unify::UnifyKey;

use hir_expand::name;

-use stdx::never;

use triomphe::Arc;

use super::{InferOk, InferResult, InferenceContext, TypeError};

@@ -92,15 +91,10 @@ pub(crate) fn unify(

let vars = Substitution::from_iter(

Interner,

tys.binders.iter(Interner).map(|it| match &it.kind {

- chalk_ir::VariableKind::Ty(_) => {

- GenericArgData::Ty(table.new_type_var()).intern(Interner)

- }

- chalk_ir::VariableKind::Lifetime => {

- GenericArgData::Ty(table.new_type_var()).intern(Interner)

- } // FIXME: maybe wrong?

- chalk_ir::VariableKind::Const(ty) => {

- GenericArgData::Const(table.new_const_var(ty.clone())).intern(Interner)

- }

+ chalk_ir::VariableKind::Ty(_) => table.new_type_var().cast(Interner),

+ // FIXME: maybe wrong?

+ chalk_ir::VariableKind::Lifetime => table.new_type_var().cast(Interner),

+ chalk_ir::VariableKind::Const(ty) => table.new_const_var(ty.clone()).cast(Interner),

}),

);

let ty1_with_vars = vars.apply(tys.value.0.clone(), Interner);

@@ -111,10 +105,10 @@ pub(crate) fn unify(

// default any type vars that weren't unified back to their original bound vars

// (kind of hacky)

let find_var = |iv| {

- vars.iter(Interner).position(|v| match v.interned() {

- chalk_ir::GenericArgData::Ty(ty) => ty.inference_var(Interner),

- chalk_ir::GenericArgData::Lifetime(lt) => lt.inference_var(Interner),

- chalk_ir::GenericArgData::Const(c) => c.inference_var(Interner),

+ vars.iter(Interner).position(|v| match v.data(Interner) {

+ GenericArgData::Ty(ty) => ty.inference_var(Interner),

+ GenericArgData::Lifetime(lt) => lt.inference_var(Interner),

+ GenericArgData::Const(c) => c.inference_var(Interner),

} == Some(iv))

};

let fallback = |iv, kind, default, binder| match kind {

@@ -611,9 +605,9 @@ impl<'a> InferenceTable<'a> {

fn check_changed(&mut self, canonicalized: &Canonicalized<InEnvironment<Goal>>) -> bool {

canonicalized.free_vars.iter().any(|var| {

let iv = match var.data(Interner) {

- chalk_ir::GenericArgData::Ty(ty) => ty.inference_var(Interner),

- chalk_ir::GenericArgData::Lifetime(lt) => lt.inference_var(Interner),

- chalk_ir::GenericArgData::Const(c) => c.inference_var(Interner),

+ GenericArgData::Ty(ty) => ty.inference_var(Interner),

+ GenericArgData::Lifetime(lt) => lt.inference_var(Interner),

+ GenericArgData::Const(c) => c.inference_var(Interner),

}

.expect("free var is not inference var");

if self.var_unification_table.probe_var(iv).is_some() {

@@ -690,14 +684,10 @@ impl<'a> InferenceTable<'a> {

.fill(|it| {

let arg = match it {

ParamKind::Type => self.new_type_var(),

- ParamKind::Const(ty) => {

- never!("Tuple with const parameter");

- return GenericArgData::Const(self.new_const_var(ty.clone()))

- .intern(Interner);

- }

+ ParamKind::Const(_) => unreachable!("Tuple with const parameter"),

};

arg_tys.push(arg.clone());

- GenericArgData::Ty(arg).intern(Interner)

+ arg.cast(Interner)

})

.build();

diff --git a/crates/hir-ty/src/lower.rs b/crates/hir-ty/src/lower.rs
index 2837f400bc..20dccfafb3 100644
--- a/crates/hir-ty/src/lower.rs
+++ b/crates/hir-ty/src/lower.rs

@@ -58,10 +58,9 @@ use crate::{

InTypeConstIdMetadata,

AliasEq, AliasTy, Binders, BoundVar, CallableSig, Const, ConstScalar, DebruijnIndex, DynTy,

- FnPointer, FnSig, FnSubst, GenericArgData, ImplTraitId, Interner, ParamKind, PolyFnSig,

- ProjectionTy, QuantifiedWhereClause, QuantifiedWhereClauses, ReturnTypeImplTrait,

- ReturnTypeImplTraits, Substitution, TraitEnvironment, TraitRef, TraitRefExt, Ty, TyBuilder,

- TyKind, WhereClause,

+ FnPointer, FnSig, FnSubst, ImplTraitId, Interner, ParamKind, PolyFnSig, ProjectionTy,

+ QuantifiedWhereClause, QuantifiedWhereClauses, ReturnTypeImplTrait, ReturnTypeImplTraits,

+ Substitution, TraitEnvironment, TraitRef, TraitRefExt, Ty, TyBuilder, TyKind, WhereClause,

};

#[derive(Debug)]

@@ -1643,9 +1642,7 @@ pub(crate) fn generic_defaults_recover(

.iter_id()

.map(|id| {

let val = match id {

- Either::Left(_) => {

- GenericArgData::Ty(TyKind::Error.intern(Interner)).intern(Interner)

- }

+ Either::Left(_) => TyKind::Error.intern(Interner).cast(Interner),

Either::Right(id) => unknown_const_as_generic(db.const_param_ty(id)),

};

crate::make_binders(db, &generic_params, val)

@@ -1991,16 +1988,9 @@ pub(crate) fn generic_arg_to_chalk<'a, T>(

}

};

Some(match (arg, kind) {

- (GenericArg::Type(type_ref), ParamKind::Type) => {

- let ty = for_type(this, type_ref);

- GenericArgData::Ty(ty).intern(Interner)

- }

- (GenericArg::Const(c), ParamKind::Const(c_ty)) => {

- GenericArgData::Const(for_const(this, c, c_ty)).intern(Interner)

- }

- (GenericArg::Const(_), ParamKind::Type) => {

- GenericArgData::Ty(TyKind::Error.intern(Interner)).intern(Interner)

- }

+ (GenericArg::Type(type_ref), ParamKind::Type) => for_type(this, type_ref).cast(Interner),

+ (GenericArg::Const(c), ParamKind::Const(c_ty)) => for_const(this, c, c_ty).cast(Interner),

+ (GenericArg::Const(_), ParamKind::Type) => TyKind::Error.intern(Interner).cast(Interner),

(GenericArg::Type(t), ParamKind::Const(c_ty)) => {

// We want to recover simple idents, which parser detects them

// as types. Maybe here is not the best place to do it, but

@@ -2010,9 +2000,7 @@ pub(crate) fn generic_arg_to_chalk<'a, T>(

if p.kind == PathKind::Plain {

if let [n] = p.segments() {

let c = ConstRef::Path(n.clone());

- return Some(

- GenericArgData::Const(for_const(this, &c, c_ty)).intern(Interner),

- );

+ return Some(for_const(this, &c, c_ty).cast(Interner));

}

diff --git a/crates/hir-ty/src/mir/eval.rs b/crates/hir-ty/src/mir/eval.rs
index 9e30eed56f..12f8264010 100644
--- a/crates/hir-ty/src/mir/eval.rs
+++ b/crates/hir-ty/src/mir/eval.rs

@@ -10,7 +10,7 @@ use std::{

};

use base_db::{CrateId, FileId};

-use chalk_ir::Mutability;

+use chalk_ir::{cast::Cast, Mutability};

use either::Either;

use hir_def::{

builtin_type::BuiltinType,

@@ -40,8 +40,8 @@ use crate::{

name, static_lifetime,

traits::FnTrait,

utils::{detect_variant_from_bytes, ClosureSubst},

- CallableDefId, ClosureId, Const, ConstScalar, FnDefId, GenericArgData, Interner, MemoryMap,

- Substitution, TraitEnvironment, Ty, TyBuilder, TyExt, TyKind,

+ CallableDefId, ClosureId, Const, ConstScalar, FnDefId, Interner, MemoryMap, Substitution,

+ TraitEnvironment, Ty, TyBuilder, TyExt, TyKind,

};

use super::{

@@ -2248,7 +2248,7 @@ impl Evaluator<'_> {

interval: args_for_target[0].interval.slice(0..self.ptr_size()),

ty: ty.clone(),

};

- let ty = GenericArgData::Ty(ty.clone()).intern(Interner);

+ let ty = ty.clone().cast(Interner);

let generics_for_target = Substitution::from_iter(

Interner,

generic_args.iter(Interner).enumerate().map(|(i, it)| {

diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index de60c88844..b1c00d816f 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs

@@ -1273,7 +1273,7 @@ impl Adt {

.fill(|x| {

let r = it.next().unwrap_or_else(|| TyKind::Error.intern(Interner));

match x {

- ParamKind::Type => GenericArgData::Ty(r).intern(Interner),

+ ParamKind::Type => r.cast(Interner),

ParamKind::Const(ty) => unknown_const_as_generic(ty.clone()),

}

})

@@ -3716,7 +3716,7 @@ impl Type {

.fill(|x| {

let r = it.next().unwrap();

match x {

- ParamKind::Type => GenericArgData::Ty(r).intern(Interner),

+ ParamKind::Type => r.cast(Interner),

ParamKind::Const(ty) => {

// FIXME: this code is not covered in tests.

unknown_const_as_generic(ty.clone())

@@ -3749,9 +3749,7 @@ impl Type {

.fill(|it| {

// FIXME: this code is not covered in tests.

match it {

- ParamKind::Type => {

- GenericArgData::Ty(args.next().unwrap().ty.clone()).intern(Interner)

- }

+ ParamKind::Type => args.next().unwrap().ty.clone().cast(Interner),

ParamKind::Const(ty) => unknown_const_as_generic(ty.clone()),

}

})