expr::BodySyntaxMapping,
ty::InferenceResult,
adt::VariantData,
- generics::Generics,
+ generics::GenericParams,
code_model_impl::def_id_to_ast,
};
def_id_to_ast(db, self.def_id)
}
- pub fn generics(&self, db: &impl HirDatabase) -> Arc<Generics> {
- db.generics(self.def_id)
+ pub fn generic_params(&self, db: &impl HirDatabase) -> Arc<GenericParams> {
+ db.generic_params(self.def_id)
}
}
def_id_to_ast(db, self.def_id)
}
- pub fn generics(&self, db: &impl HirDatabase) -> Arc<Generics> {
- db.generics(self.def_id)
+ pub fn generic_params(&self, db: &impl HirDatabase) -> Arc<GenericParams> {
+ db.generic_params(self.def_id)
}
}
db.infer(self.def_id)
}
- pub fn generics(&self, db: &impl HirDatabase) -> Arc<Generics> {
- db.generics(self.def_id)
+ pub fn generic_params(&self, db: &impl HirDatabase) -> Arc<GenericParams> {
+ db.generic_params(self.def_id)
}
}
def_id_to_ast(db, self.def_id)
}
- pub fn generics(&self, db: &impl HirDatabase) -> Arc<Generics> {
- db.generics(self.def_id)
+ pub fn generic_params(&self, db: &impl HirDatabase) -> Arc<GenericParams> {
+ db.generic_params(self.def_id)
}
}
def_id_to_ast(db, self.def_id)
}
- pub fn generics(&self, db: &impl HirDatabase) -> Arc<Generics> {
- db.generics(self.def_id)
+ pub fn generic_params(&self, db: &impl HirDatabase) -> Arc<GenericParams> {
+ db.generic_params(self.def_id)
}
}
type_ref::{TypeRef, Mutability},
name::KnownName,
expr::{Body, Expr, BindingAnnotation, Literal, ExprId, Pat, PatId, UnaryOp, BinaryOp, Statement, FieldPat},
- generics::Generics,
+ generics::GenericParams,
path::GenericArg,
};
// resolver architecture
module: &Module,
impl_block: Option<&ImplBlock>,
- generics: &Generics,
+ generics: &GenericParams,
type_ref: &TypeRef,
) -> Self {
match type_ref {
db: &impl HirDatabase,
module: &Module,
impl_block: Option<&ImplBlock>,
- generics: &Generics,
+ generics: &GenericParams,
type_ref: Option<&TypeRef>,
) -> Self {
type_ref.map_or(Ty::Unknown, |t| {
db: &impl HirDatabase,
module: &Module,
impl_block: Option<&ImplBlock>,
- generics: &Generics,
+ generics: &GenericParams,
path: &Path,
) -> Self {
if let Some(name) = path.as_ident() {
return Ty::Float(float_ty);
} else if name.as_known_name() == Some(KnownName::SelfType) {
// TODO pass the impl block's generics?
- let generics = &Generics::default();
+ let generics = &GenericParams::default();
return Ty::from_hir_opt(
db,
module,
// the scope of the segment...
module: &Module,
impl_block: Option<&ImplBlock>,
- outer_generics: &Generics,
+ outer_generics: &GenericParams,
path: &Path,
resolved: DefId,
) -> Substs {
.last()
.expect("path should have at least one segment");
let (def_generics, segment) = match def {
- Def::Struct(s) => (s.generics(db), last),
- Def::Enum(e) => (e.generics(db), last),
- Def::Function(f) => (f.generics(db), last),
- Def::Trait(t) => (t.generics(db), last),
+ Def::Struct(s) => (s.generic_params(db), last),
+ Def::Enum(e) => (e.generic_params(db), last),
+ Def::Function(f) => (f.generic_params(db), last),
+ Def::Trait(t) => (t.generic_params(db), last),
Def::EnumVariant(ev) => {
// the generic args for an enum variant may be either specified
// on the segment referring to the enum, or on the segment
// Option::None::<T>
last
};
- (ev.parent_enum(db).generics(db), segment)
+ (ev.parent_enum(db).generic_params(db), segment)
}
_ => return Substs::empty(),
};
let signature = f.signature(db);
let module = f.module(db);
let impl_block = f.impl_block(db);
- let generics = f.generics(db);
+ let generics = f.generic_params(db);
let input = signature
.params()
.iter()
Ty::FnPtr(Arc::new(sig))
}
-fn make_substs(generics: &Generics) -> Substs {
+fn make_substs(generics: &GenericParams) -> Substs {
Substs(
generics
.params
}
fn type_for_struct(db: &impl HirDatabase, s: Struct) -> Ty {
- let generics = s.generics(db);
+ let generics = s.generic_params(db);
Ty::Adt {
def_id: s.def_id(),
name: s.name(db).unwrap_or_else(Name::missing),
}
pub(crate) fn type_for_enum(db: &impl HirDatabase, s: Enum) -> Ty {
- let generics = s.generics(db);
+ let generics = s.generic_params(db);
Ty::Adt {
def_id: s.def_id(),
name: s.name(db).unwrap_or_else(Name::missing),
pub(super) fn type_for_field(db: &impl HirDatabase, def_id: DefId, field: Name) -> Option<Ty> {
let def = def_id.resolve(db);
let (variant_data, generics) = match def {
- Def::Struct(s) => (s.variant_data(db), s.generics(db)),
- Def::EnumVariant(ev) => (ev.variant_data(db), ev.parent_enum(db).generics(db)),
+ Def::Struct(s) => (s.variant_data(db), s.generic_params(db)),
+ Def::EnumVariant(ev) => (ev.variant_data(db), ev.parent_enum(db).generic_params(db)),
// TODO: unions
_ => panic!(
"trying to get type for field in non-struct/variant {:?}",
fn make_ty(&mut self, type_ref: &TypeRef) -> Ty {
// TODO provide generics of function
- let generics = Generics::default();
+ let generics = GenericParams::default();
let ty = Ty::from_hir(
self.db,
&self.module,
};
// TODO remove the duplication between here and `Ty::from_path`?
// TODO provide generics of function
- let generics = Generics::default();
+ let generics = GenericParams::default();
let substs = Ty::substs_from_path(
self.db,
&self.module,