diff options
author | bors[bot] <bors[bot]@users.noreply.github.com> | 2019-02-25 12:03:57 +0000 |
---|---|---|
committer | bors[bot] <bors[bot]@users.noreply.github.com> | 2019-02-25 12:03:57 +0000 |
commit | 7c9acf2f834c582d9cad4f7d0679a0697c591432 (patch) | |
tree | 5829e5a0e4567c532a5d430ed9406a8cd072f5ca /crates/ra_hir/src/ty/lower.rs | |
parent | 4f67df904252c5fbbf3b892bb2e8405778bc904a (diff) | |
parent | cff9a7dfadc6069bbc7b49c3ceb8497c78d426ab (diff) |
Merge #897
897: Add basic const/static type inference r=flodiebold a=vipentti
This adds basic const/static type inference discussed in #887.
Currently the inference does not work for const/static declared inside a block. In addition the inference does not work inside the bodies of const/static.
Co-authored-by: Ville Penttinen <[email protected]>
Diffstat (limited to 'crates/ra_hir/src/ty/lower.rs')
-rw-r--r-- | crates/ra_hir/src/ty/lower.rs | 35 |
1 files changed, 30 insertions, 5 deletions
diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs index b66b8e4a5..f4e055feb 100644 --- a/crates/ra_hir/src/ty/lower.rs +++ b/crates/ra_hir/src/ty/lower.rs | |||
@@ -11,6 +11,7 @@ use std::sync::Arc; | |||
11 | use crate::{ | 11 | use crate::{ |
12 | Function, Struct, StructField, Enum, EnumVariant, Path, Name, | 12 | Function, Struct, StructField, Enum, EnumVariant, Path, Name, |
13 | ModuleDef, TypeAlias, | 13 | ModuleDef, TypeAlias, |
14 | Const, Static, | ||
14 | HirDatabase, | 15 | HirDatabase, |
15 | type_ref::TypeRef, | 16 | type_ref::TypeRef, |
16 | name::KnownName, | 17 | name::KnownName, |
@@ -125,6 +126,7 @@ impl Ty { | |||
125 | TypableDef::Enum(e) => e.generic_params(db), | 126 | TypableDef::Enum(e) => e.generic_params(db), |
126 | TypableDef::EnumVariant(var) => var.parent_enum(db).generic_params(db), | 127 | TypableDef::EnumVariant(var) => var.parent_enum(db).generic_params(db), |
127 | TypableDef::TypeAlias(t) => t.generic_params(db), | 128 | TypableDef::TypeAlias(t) => t.generic_params(db), |
129 | TypableDef::Const(_) | TypableDef::Static(_) => GenericParams::default().into(), | ||
128 | }; | 130 | }; |
129 | let parent_param_count = def_generics.count_parent_params(); | 131 | let parent_param_count = def_generics.count_parent_params(); |
130 | substs.extend((0..parent_param_count).map(|_| Ty::Unknown)); | 132 | substs.extend((0..parent_param_count).map(|_| Ty::Unknown)); |
@@ -163,6 +165,8 @@ impl Ty { | |||
163 | TypableDef::Function(_) | 165 | TypableDef::Function(_) |
164 | | TypableDef::Struct(_) | 166 | | TypableDef::Struct(_) |
165 | | TypableDef::Enum(_) | 167 | | TypableDef::Enum(_) |
168 | | TypableDef::Const(_) | ||
169 | | TypableDef::Static(_) | ||
166 | | TypableDef::TypeAlias(_) => last, | 170 | | TypableDef::TypeAlias(_) => last, |
167 | TypableDef::EnumVariant(_) => { | 171 | TypableDef::EnumVariant(_) => { |
168 | // the generic args for an enum variant may be either specified | 172 | // the generic args for an enum variant may be either specified |
@@ -197,12 +201,16 @@ pub(crate) fn type_for_def(db: &impl HirDatabase, def: TypableDef, ns: Namespace | |||
197 | (TypableDef::Enum(e), Namespace::Types) => type_for_enum(db, e), | 201 | (TypableDef::Enum(e), Namespace::Types) => type_for_enum(db, e), |
198 | (TypableDef::EnumVariant(v), Namespace::Values) => type_for_enum_variant_constructor(db, v), | 202 | (TypableDef::EnumVariant(v), Namespace::Values) => type_for_enum_variant_constructor(db, v), |
199 | (TypableDef::TypeAlias(t), Namespace::Types) => type_for_type_alias(db, t), | 203 | (TypableDef::TypeAlias(t), Namespace::Types) => type_for_type_alias(db, t), |
204 | (TypableDef::Const(c), Namespace::Values) => type_for_const(db, c), | ||
205 | (TypableDef::Static(c), Namespace::Values) => type_for_static(db, c), | ||
200 | 206 | ||
201 | // 'error' cases: | 207 | // 'error' cases: |
202 | (TypableDef::Function(_), Namespace::Types) => Ty::Unknown, | 208 | (TypableDef::Function(_), Namespace::Types) => Ty::Unknown, |
203 | (TypableDef::Enum(_), Namespace::Values) => Ty::Unknown, | 209 | (TypableDef::Enum(_), Namespace::Values) => Ty::Unknown, |
204 | (TypableDef::EnumVariant(_), Namespace::Types) => Ty::Unknown, | 210 | (TypableDef::EnumVariant(_), Namespace::Types) => Ty::Unknown, |
205 | (TypableDef::TypeAlias(_), Namespace::Values) => Ty::Unknown, | 211 | (TypableDef::TypeAlias(_), Namespace::Values) => Ty::Unknown, |
212 | (TypableDef::Const(_), Namespace::Types) => Ty::Unknown, | ||
213 | (TypableDef::Static(_), Namespace::Types) => Ty::Unknown, | ||
206 | } | 214 | } |
207 | } | 215 | } |
208 | 216 | ||
@@ -233,6 +241,22 @@ fn type_for_fn(db: &impl HirDatabase, def: Function) -> Ty { | |||
233 | Ty::FnDef { def: def.into(), sig, name, substs } | 241 | Ty::FnDef { def: def.into(), sig, name, substs } |
234 | } | 242 | } |
235 | 243 | ||
244 | /// Build the declared type of a const. | ||
245 | fn type_for_const(db: &impl HirDatabase, def: Const) -> Ty { | ||
246 | let signature = def.signature(db); | ||
247 | let resolver = def.resolver(db); | ||
248 | |||
249 | Ty::from_hir(db, &resolver, signature.type_ref()) | ||
250 | } | ||
251 | |||
252 | /// Build the declared type of a static. | ||
253 | fn type_for_static(db: &impl HirDatabase, def: Static) -> Ty { | ||
254 | let signature = def.signature(db); | ||
255 | let resolver = def.resolver(db); | ||
256 | |||
257 | Ty::from_hir(db, &resolver, signature.type_ref()) | ||
258 | } | ||
259 | |||
236 | /// Build the type of a tuple struct constructor. | 260 | /// Build the type of a tuple struct constructor. |
237 | fn type_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> Ty { | 261 | fn type_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> Ty { |
238 | let var_data = def.variant_data(db); | 262 | let var_data = def.variant_data(db); |
@@ -318,8 +342,10 @@ pub enum TypableDef { | |||
318 | Enum(Enum), | 342 | Enum(Enum), |
319 | EnumVariant(EnumVariant), | 343 | EnumVariant(EnumVariant), |
320 | TypeAlias(TypeAlias), | 344 | TypeAlias(TypeAlias), |
345 | Const(Const), | ||
346 | Static(Static), | ||
321 | } | 347 | } |
322 | impl_froms!(TypableDef: Function, Struct, Enum, EnumVariant, TypeAlias); | 348 | impl_froms!(TypableDef: Function, Struct, Enum, EnumVariant, TypeAlias, Const, Static); |
323 | 349 | ||
324 | impl From<ModuleDef> for Option<TypableDef> { | 350 | impl From<ModuleDef> for Option<TypableDef> { |
325 | fn from(def: ModuleDef) -> Option<TypableDef> { | 351 | fn from(def: ModuleDef) -> Option<TypableDef> { |
@@ -329,10 +355,9 @@ impl From<ModuleDef> for Option<TypableDef> { | |||
329 | ModuleDef::Enum(e) => e.into(), | 355 | ModuleDef::Enum(e) => e.into(), |
330 | ModuleDef::EnumVariant(v) => v.into(), | 356 | ModuleDef::EnumVariant(v) => v.into(), |
331 | ModuleDef::TypeAlias(t) => t.into(), | 357 | ModuleDef::TypeAlias(t) => t.into(), |
332 | ModuleDef::Const(_) | 358 | ModuleDef::Const(v) => v.into(), |
333 | | ModuleDef::Static(_) | 359 | ModuleDef::Static(v) => v.into(), |
334 | | ModuleDef::Module(_) | 360 | ModuleDef::Module(_) | ModuleDef::Trait(_) => return None, |
335 | | ModuleDef::Trait(_) => return None, | ||
336 | }; | 361 | }; |
337 | Some(res) | 362 | Some(res) |
338 | } | 363 | } |