diff options
author | Florian Diebold <[email protected]> | 2019-03-21 21:20:03 +0000 |
---|---|---|
committer | Florian Diebold <[email protected]> | 2019-03-21 21:20:03 +0000 |
commit | f10f5a81b326d161d9ed1fba263de972b89de2bf (patch) | |
tree | f54d83e74161c51cf8525213bf221b83d276de85 /crates/ra_hir/src/ty/lower.rs | |
parent | 8a5fbf471305894094726834f7701747fce9c961 (diff) |
TypeName => TypeCtor
Diffstat (limited to 'crates/ra_hir/src/ty/lower.rs')
-rw-r--r-- | crates/ra_hir/src/ty/lower.rs | 36 |
1 files changed, 18 insertions, 18 deletions
diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs index a346879d8..72b1234bf 100644 --- a/crates/ra_hir/src/ty/lower.rs +++ b/crates/ra_hir/src/ty/lower.rs | |||
@@ -19,40 +19,40 @@ use crate::{ | |||
19 | generics::GenericParams, | 19 | generics::GenericParams, |
20 | adt::VariantDef, | 20 | adt::VariantDef, |
21 | }; | 21 | }; |
22 | use super::{Ty, primitive, FnSig, Substs, TypeName}; | 22 | use super::{Ty, primitive, FnSig, Substs, TypeCtor}; |
23 | 23 | ||
24 | impl Ty { | 24 | impl Ty { |
25 | pub(crate) fn from_hir(db: &impl HirDatabase, resolver: &Resolver, type_ref: &TypeRef) -> Self { | 25 | pub(crate) fn from_hir(db: &impl HirDatabase, resolver: &Resolver, type_ref: &TypeRef) -> Self { |
26 | match type_ref { | 26 | match type_ref { |
27 | TypeRef::Never => Ty::simple(TypeName::Never), | 27 | TypeRef::Never => Ty::simple(TypeCtor::Never), |
28 | TypeRef::Tuple(inner) => { | 28 | TypeRef::Tuple(inner) => { |
29 | let inner_tys = | 29 | let inner_tys = |
30 | inner.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect::<Vec<_>>(); | 30 | inner.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect::<Vec<_>>(); |
31 | Ty::apply(TypeName::Tuple, Substs(inner_tys.into())) | 31 | Ty::apply(TypeCtor::Tuple, Substs(inner_tys.into())) |
32 | } | 32 | } |
33 | TypeRef::Path(path) => Ty::from_hir_path(db, resolver, path), | 33 | TypeRef::Path(path) => Ty::from_hir_path(db, resolver, path), |
34 | TypeRef::RawPtr(inner, mutability) => { | 34 | TypeRef::RawPtr(inner, mutability) => { |
35 | let inner_ty = Ty::from_hir(db, resolver, inner); | 35 | let inner_ty = Ty::from_hir(db, resolver, inner); |
36 | Ty::apply_one(TypeName::RawPtr(*mutability), inner_ty) | 36 | Ty::apply_one(TypeCtor::RawPtr(*mutability), inner_ty) |
37 | } | 37 | } |
38 | TypeRef::Array(inner) => { | 38 | TypeRef::Array(inner) => { |
39 | let inner_ty = Ty::from_hir(db, resolver, inner); | 39 | let inner_ty = Ty::from_hir(db, resolver, inner); |
40 | Ty::apply_one(TypeName::Array, inner_ty) | 40 | Ty::apply_one(TypeCtor::Array, inner_ty) |
41 | } | 41 | } |
42 | TypeRef::Slice(inner) => { | 42 | TypeRef::Slice(inner) => { |
43 | let inner_ty = Ty::from_hir(db, resolver, inner); | 43 | let inner_ty = Ty::from_hir(db, resolver, inner); |
44 | Ty::apply_one(TypeName::Slice, inner_ty) | 44 | Ty::apply_one(TypeCtor::Slice, inner_ty) |
45 | } | 45 | } |
46 | TypeRef::Reference(inner, mutability) => { | 46 | TypeRef::Reference(inner, mutability) => { |
47 | let inner_ty = Ty::from_hir(db, resolver, inner); | 47 | let inner_ty = Ty::from_hir(db, resolver, inner); |
48 | Ty::apply_one(TypeName::Ref(*mutability), inner_ty) | 48 | Ty::apply_one(TypeCtor::Ref(*mutability), inner_ty) |
49 | } | 49 | } |
50 | TypeRef::Placeholder => Ty::Unknown, | 50 | TypeRef::Placeholder => Ty::Unknown, |
51 | TypeRef::Fn(params) => { | 51 | TypeRef::Fn(params) => { |
52 | let inner_tys = | 52 | let inner_tys = |
53 | params.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect::<Vec<_>>(); | 53 | params.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect::<Vec<_>>(); |
54 | let sig = Substs(inner_tys.into()); | 54 | let sig = Substs(inner_tys.into()); |
55 | Ty::apply(TypeName::FnPtr, sig) | 55 | Ty::apply(TypeCtor::FnPtr, sig) |
56 | } | 56 | } |
57 | TypeRef::Error => Ty::Unknown, | 57 | TypeRef::Error => Ty::Unknown, |
58 | } | 58 | } |
@@ -62,14 +62,14 @@ impl Ty { | |||
62 | if let Some(name) = path.as_ident() { | 62 | if let Some(name) = path.as_ident() { |
63 | // TODO handle primitive type names in resolver as well? | 63 | // TODO handle primitive type names in resolver as well? |
64 | if let Some(int_ty) = primitive::UncertainIntTy::from_type_name(name) { | 64 | if let Some(int_ty) = primitive::UncertainIntTy::from_type_name(name) { |
65 | return Ty::simple(TypeName::Int(int_ty)); | 65 | return Ty::simple(TypeCtor::Int(int_ty)); |
66 | } else if let Some(float_ty) = primitive::UncertainFloatTy::from_type_name(name) { | 66 | } else if let Some(float_ty) = primitive::UncertainFloatTy::from_type_name(name) { |
67 | return Ty::simple(TypeName::Float(float_ty)); | 67 | return Ty::simple(TypeCtor::Float(float_ty)); |
68 | } else if let Some(known) = name.as_known_name() { | 68 | } else if let Some(known) = name.as_known_name() { |
69 | match known { | 69 | match known { |
70 | KnownName::Bool => return Ty::simple(TypeName::Bool), | 70 | KnownName::Bool => return Ty::simple(TypeCtor::Bool), |
71 | KnownName::Char => return Ty::simple(TypeName::Char), | 71 | KnownName::Char => return Ty::simple(TypeCtor::Char), |
72 | KnownName::Str => return Ty::simple(TypeName::Str), | 72 | KnownName::Str => return Ty::simple(TypeCtor::Str), |
73 | _ => {} | 73 | _ => {} |
74 | } | 74 | } |
75 | } | 75 | } |
@@ -245,7 +245,7 @@ fn fn_sig_for_fn(db: &impl HirDatabase, def: Function) -> FnSig { | |||
245 | fn type_for_fn(db: &impl HirDatabase, def: Function) -> Ty { | 245 | fn type_for_fn(db: &impl HirDatabase, def: Function) -> Ty { |
246 | let generics = def.generic_params(db); | 246 | let generics = def.generic_params(db); |
247 | let substs = make_substs(&generics); | 247 | let substs = make_substs(&generics); |
248 | Ty::apply(TypeName::FnDef(def.into()), substs) | 248 | Ty::apply(TypeCtor::FnDef(def.into()), substs) |
249 | } | 249 | } |
250 | 250 | ||
251 | /// Build the declared type of a const. | 251 | /// Build the declared type of a const. |
@@ -287,7 +287,7 @@ fn type_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> Ty { | |||
287 | } | 287 | } |
288 | let generics = def.generic_params(db); | 288 | let generics = def.generic_params(db); |
289 | let substs = make_substs(&generics); | 289 | let substs = make_substs(&generics); |
290 | Ty::apply(TypeName::FnDef(def.into()), substs) | 290 | Ty::apply(TypeCtor::FnDef(def.into()), substs) |
291 | } | 291 | } |
292 | 292 | ||
293 | fn fn_sig_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant) -> FnSig { | 293 | fn fn_sig_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant) -> FnSig { |
@@ -315,7 +315,7 @@ fn type_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant) -> | |||
315 | } | 315 | } |
316 | let generics = def.parent_enum(db).generic_params(db); | 316 | let generics = def.parent_enum(db).generic_params(db); |
317 | let substs = make_substs(&generics); | 317 | let substs = make_substs(&generics); |
318 | Ty::apply(TypeName::FnDef(def.into()), substs) | 318 | Ty::apply(TypeCtor::FnDef(def.into()), substs) |
319 | } | 319 | } |
320 | 320 | ||
321 | fn make_substs(generics: &GenericParams) -> Substs { | 321 | fn make_substs(generics: &GenericParams) -> Substs { |
@@ -331,12 +331,12 @@ fn make_substs(generics: &GenericParams) -> Substs { | |||
331 | 331 | ||
332 | fn type_for_struct(db: &impl HirDatabase, s: Struct) -> Ty { | 332 | fn type_for_struct(db: &impl HirDatabase, s: Struct) -> Ty { |
333 | let generics = s.generic_params(db); | 333 | let generics = s.generic_params(db); |
334 | Ty::apply(TypeName::Adt(s.into()), make_substs(&generics)) | 334 | Ty::apply(TypeCtor::Adt(s.into()), make_substs(&generics)) |
335 | } | 335 | } |
336 | 336 | ||
337 | fn type_for_enum(db: &impl HirDatabase, s: Enum) -> Ty { | 337 | fn type_for_enum(db: &impl HirDatabase, s: Enum) -> Ty { |
338 | let generics = s.generic_params(db); | 338 | let generics = s.generic_params(db); |
339 | Ty::apply(TypeName::Adt(s.into()), make_substs(&generics)) | 339 | Ty::apply(TypeCtor::Adt(s.into()), make_substs(&generics)) |
340 | } | 340 | } |
341 | 341 | ||
342 | fn type_for_type_alias(db: &impl HirDatabase, t: TypeAlias) -> Ty { | 342 | fn type_for_type_alias(db: &impl HirDatabase, t: TypeAlias) -> Ty { |