diff options
author | Aleksey Kladov <[email protected]> | 2019-02-08 11:49:43 +0000 |
---|---|---|
committer | Aleksey Kladov <[email protected]> | 2019-02-08 11:49:43 +0000 |
commit | 12e3b4c70b5ef23b2fdfc197296d483680e125f9 (patch) | |
tree | 71baa0e0a62f9f6b61450501c5f821f67badf9e4 /crates/ra_hir/src/ty.rs | |
parent | 5cb1d41a30d25cbe136402644bf5434dd667f1e5 (diff) |
reformat the world
Diffstat (limited to 'crates/ra_hir/src/ty.rs')
-rw-r--r-- | crates/ra_hir/src/ty.rs | 249 |
1 files changed, 62 insertions, 187 deletions
diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs index 86a7f8b83..453520bbe 100644 --- a/crates/ra_hir/src/ty.rs +++ b/crates/ra_hir/src/ty.rs | |||
@@ -305,10 +305,8 @@ impl Ty { | |||
305 | match type_ref { | 305 | match type_ref { |
306 | TypeRef::Never => Ty::Never, | 306 | TypeRef::Never => Ty::Never, |
307 | TypeRef::Tuple(inner) => { | 307 | TypeRef::Tuple(inner) => { |
308 | let inner_tys = inner | 308 | let inner_tys = |
309 | .iter() | 309 | inner.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect::<Vec<_>>(); |
310 | .map(|tr| Ty::from_hir(db, resolver, tr)) | ||
311 | .collect::<Vec<_>>(); | ||
312 | Ty::Tuple(inner_tys.into()) | 310 | Ty::Tuple(inner_tys.into()) |
313 | } | 311 | } |
314 | TypeRef::Path(path) => Ty::from_hir_path(db, resolver, path), | 312 | TypeRef::Path(path) => Ty::from_hir_path(db, resolver, path), |
@@ -330,17 +328,11 @@ impl Ty { | |||
330 | } | 328 | } |
331 | TypeRef::Placeholder => Ty::Unknown, | 329 | TypeRef::Placeholder => Ty::Unknown, |
332 | TypeRef::Fn(params) => { | 330 | TypeRef::Fn(params) => { |
333 | let mut inner_tys = params | 331 | let mut inner_tys = |
334 | .iter() | 332 | params.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect::<Vec<_>>(); |
335 | .map(|tr| Ty::from_hir(db, resolver, tr)) | 333 | let return_ty = |
336 | .collect::<Vec<_>>(); | 334 | inner_tys.pop().expect("TypeRef::Fn should always have at least return type"); |
337 | let return_ty = inner_tys | 335 | let sig = FnSig { input: inner_tys, output: return_ty }; |
338 | .pop() | ||
339 | .expect("TypeRef::Fn should always have at least return type"); | ||
340 | let sig = FnSig { | ||
341 | input: inner_tys, | ||
342 | output: return_ty, | ||
343 | }; | ||
344 | Ty::FnPtr(Arc::new(sig)) | 336 | Ty::FnPtr(Arc::new(sig)) |
345 | } | 337 | } |
346 | TypeRef::Error => Ty::Unknown, | 338 | TypeRef::Error => Ty::Unknown, |
@@ -407,10 +399,7 @@ impl Ty { | |||
407 | resolved: TypableDef, | 399 | resolved: TypableDef, |
408 | ) -> Substs { | 400 | ) -> Substs { |
409 | let mut substs = Vec::new(); | 401 | let mut substs = Vec::new(); |
410 | let last = path | 402 | let last = path.segments.last().expect("path should have at least one segment"); |
411 | .segments | ||
412 | .last() | ||
413 | .expect("path should have at least one segment"); | ||
414 | let (def_generics, segment) = match resolved { | 403 | let (def_generics, segment) = match resolved { |
415 | TypableDef::Function(func) => (func.generic_params(db), last), | 404 | TypableDef::Function(func) => (func.generic_params(db), last), |
416 | TypableDef::Struct(s) => (s.generic_params(db), last), | 405 | TypableDef::Struct(s) => (s.generic_params(db), last), |
@@ -447,11 +436,8 @@ impl Ty { | |||
447 | } | 436 | } |
448 | // add placeholders for args that were not provided | 437 | // add placeholders for args that were not provided |
449 | // TODO: handle defaults | 438 | // TODO: handle defaults |
450 | let supplied_params = segment | 439 | let supplied_params = |
451 | .args_and_bindings | 440 | segment.args_and_bindings.as_ref().map(|ga| ga.args.len()).unwrap_or(0); |
452 | .as_ref() | ||
453 | .map(|ga| ga.args.len()) | ||
454 | .unwrap_or(0); | ||
455 | for _ in supplied_params..def_generics.params.len() { | 441 | for _ in supplied_params..def_generics.params.len() { |
456 | substs.push(Ty::Unknown); | 442 | substs.push(Ty::Unknown); |
457 | } | 443 | } |
@@ -531,17 +517,8 @@ impl Ty { | |||
531 | /// `Option<u32>` afterwards.) | 517 | /// `Option<u32>` afterwards.) |
532 | pub fn apply_substs(self, substs: Substs) -> Ty { | 518 | pub fn apply_substs(self, substs: Substs) -> Ty { |
533 | match self { | 519 | match self { |
534 | Ty::Adt { def_id, name, .. } => Ty::Adt { | 520 | Ty::Adt { def_id, name, .. } => Ty::Adt { def_id, name, substs }, |
535 | def_id, | 521 | Ty::FnDef { def, name, sig, .. } => Ty::FnDef { def, name, sig, substs }, |
536 | name, | ||
537 | substs, | ||
538 | }, | ||
539 | Ty::FnDef { def, name, sig, .. } => Ty::FnDef { | ||
540 | def, | ||
541 | name, | ||
542 | sig, | ||
543 | substs, | ||
544 | }, | ||
545 | _ => self, | 522 | _ => self, |
546 | } | 523 | } |
547 | } | 524 | } |
@@ -591,42 +568,25 @@ impl fmt::Display for Ty { | |||
591 | if ts.len() == 1 { | 568 | if ts.len() == 1 { |
592 | write!(f, "({},)", ts[0]) | 569 | write!(f, "({},)", ts[0]) |
593 | } else { | 570 | } else { |
594 | join(ts.iter()) | 571 | join(ts.iter()).surround_with("(", ")").separator(", ").to_fmt(f) |
595 | .surround_with("(", ")") | ||
596 | .separator(", ") | ||
597 | .to_fmt(f) | ||
598 | } | 572 | } |
599 | } | 573 | } |
600 | Ty::FnPtr(sig) => { | 574 | Ty::FnPtr(sig) => { |
601 | join(sig.input.iter()) | 575 | join(sig.input.iter()).surround_with("fn(", ")").separator(", ").to_fmt(f)?; |
602 | .surround_with("fn(", ")") | ||
603 | .separator(", ") | ||
604 | .to_fmt(f)?; | ||
605 | write!(f, " -> {}", sig.output) | 576 | write!(f, " -> {}", sig.output) |
606 | } | 577 | } |
607 | Ty::FnDef { | 578 | Ty::FnDef { name, substs, sig, .. } => { |
608 | name, substs, sig, .. | ||
609 | } => { | ||
610 | write!(f, "fn {}", name)?; | 579 | write!(f, "fn {}", name)?; |
611 | if substs.0.len() > 0 { | 580 | if substs.0.len() > 0 { |
612 | join(substs.0.iter()) | 581 | join(substs.0.iter()).surround_with("<", ">").separator(", ").to_fmt(f)?; |
613 | .surround_with("<", ">") | ||
614 | .separator(", ") | ||
615 | .to_fmt(f)?; | ||
616 | } | 582 | } |
617 | join(sig.input.iter()) | 583 | join(sig.input.iter()).surround_with("(", ")").separator(", ").to_fmt(f)?; |
618 | .surround_with("(", ")") | ||
619 | .separator(", ") | ||
620 | .to_fmt(f)?; | ||
621 | write!(f, " -> {}", sig.output) | 584 | write!(f, " -> {}", sig.output) |
622 | } | 585 | } |
623 | Ty::Adt { name, substs, .. } => { | 586 | Ty::Adt { name, substs, .. } => { |
624 | write!(f, "{}", name)?; | 587 | write!(f, "{}", name)?; |
625 | if substs.0.len() > 0 { | 588 | if substs.0.len() > 0 { |
626 | join(substs.0.iter()) | 589 | join(substs.0.iter()).surround_with("<", ">").separator(", ").to_fmt(f)?; |
627 | .surround_with("<", ">") | ||
628 | .separator(", ") | ||
629 | .to_fmt(f)?; | ||
630 | } | 590 | } |
631 | Ok(()) | 591 | Ok(()) |
632 | } | 592 | } |
@@ -646,31 +606,16 @@ fn type_for_fn(db: &impl HirDatabase, def: Function) -> Ty { | |||
646 | let resolver = def.resolver(db); | 606 | let resolver = def.resolver(db); |
647 | let generics = def.generic_params(db); | 607 | let generics = def.generic_params(db); |
648 | let name = def.name(db); | 608 | let name = def.name(db); |
649 | let input = signature | 609 | let input = |
650 | .params() | 610 | signature.params().iter().map(|tr| Ty::from_hir(db, &resolver, tr)).collect::<Vec<_>>(); |
651 | .iter() | ||
652 | .map(|tr| Ty::from_hir(db, &resolver, tr)) | ||
653 | .collect::<Vec<_>>(); | ||
654 | let output = Ty::from_hir(db, &resolver, signature.ret_type()); | 611 | let output = Ty::from_hir(db, &resolver, signature.ret_type()); |
655 | let sig = Arc::new(FnSig { input, output }); | 612 | let sig = Arc::new(FnSig { input, output }); |
656 | let substs = make_substs(&generics); | 613 | let substs = make_substs(&generics); |
657 | Ty::FnDef { | 614 | Ty::FnDef { def, sig, name, substs } |
658 | def, | ||
659 | sig, | ||
660 | name, | ||
661 | substs, | ||
662 | } | ||
663 | } | 615 | } |
664 | 616 | ||
665 | fn make_substs(generics: &GenericParams) -> Substs { | 617 | fn make_substs(generics: &GenericParams) -> Substs { |
666 | Substs( | 618 | Substs(generics.params.iter().map(|_p| Ty::Unknown).collect::<Vec<_>>().into()) |
667 | generics | ||
668 | .params | ||
669 | .iter() | ||
670 | .map(|_p| Ty::Unknown) | ||
671 | .collect::<Vec<_>>() | ||
672 | .into(), | ||
673 | ) | ||
674 | } | 619 | } |
675 | 620 | ||
676 | fn type_for_struct(db: &impl HirDatabase, s: Struct) -> Ty { | 621 | fn type_for_struct(db: &impl HirDatabase, s: Struct) -> Ty { |
@@ -935,11 +880,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { | |||
935 | } | 880 | } |
936 | 881 | ||
937 | fn unify_substs(&mut self, substs1: &Substs, substs2: &Substs) -> bool { | 882 | fn unify_substs(&mut self, substs1: &Substs, substs2: &Substs) -> bool { |
938 | substs1 | 883 | substs1.0.iter().zip(substs2.0.iter()).all(|(t1, t2)| self.unify(t1, t2)) |
939 | .0 | ||
940 | .iter() | ||
941 | .zip(substs2.0.iter()) | ||
942 | .all(|(t1, t2)| self.unify(t1, t2)) | ||
943 | } | 884 | } |
944 | 885 | ||
945 | fn unify(&mut self, ty1: &Ty, ty2: &Ty) -> bool { | 886 | fn unify(&mut self, ty1: &Ty, ty2: &Ty) -> bool { |
@@ -961,25 +902,16 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { | |||
961 | }, | 902 | }, |
962 | (Ty::Bool, _) | (Ty::Str, _) | (Ty::Never, _) | (Ty::Char, _) => ty1 == ty2, | 903 | (Ty::Bool, _) | (Ty::Str, _) | (Ty::Never, _) | (Ty::Char, _) => ty1 == ty2, |
963 | ( | 904 | ( |
964 | Ty::Adt { | 905 | Ty::Adt { def_id: def_id1, substs: substs1, .. }, |
965 | def_id: def_id1, | 906 | Ty::Adt { def_id: def_id2, substs: substs2, .. }, |
966 | substs: substs1, | ||
967 | .. | ||
968 | }, | ||
969 | Ty::Adt { | ||
970 | def_id: def_id2, | ||
971 | substs: substs2, | ||
972 | .. | ||
973 | }, | ||
974 | ) if def_id1 == def_id2 => self.unify_substs(substs1, substs2), | 907 | ) if def_id1 == def_id2 => self.unify_substs(substs1, substs2), |
975 | (Ty::Slice(t1), Ty::Slice(t2)) => self.unify(t1, t2), | 908 | (Ty::Slice(t1), Ty::Slice(t2)) => self.unify(t1, t2), |
976 | (Ty::RawPtr(t1, m1), Ty::RawPtr(t2, m2)) if m1 == m2 => self.unify(t1, t2), | 909 | (Ty::RawPtr(t1, m1), Ty::RawPtr(t2, m2)) if m1 == m2 => self.unify(t1, t2), |
977 | (Ty::Ref(t1, m1), Ty::Ref(t2, m2)) if m1 == m2 => self.unify(t1, t2), | 910 | (Ty::Ref(t1, m1), Ty::Ref(t2, m2)) if m1 == m2 => self.unify(t1, t2), |
978 | (Ty::FnPtr(sig1), Ty::FnPtr(sig2)) if sig1 == sig2 => true, | 911 | (Ty::FnPtr(sig1), Ty::FnPtr(sig2)) if sig1 == sig2 => true, |
979 | (Ty::Tuple(ts1), Ty::Tuple(ts2)) if ts1.len() == ts2.len() => ts1 | 912 | (Ty::Tuple(ts1), Ty::Tuple(ts2)) if ts1.len() == ts2.len() => { |
980 | .iter() | 913 | ts1.iter().zip(ts2.iter()).all(|(t1, t2)| self.unify(t1, t2)) |
981 | .zip(ts2.iter()) | 914 | } |
982 | .all(|(t1, t2)| self.unify(t1, t2)), | ||
983 | (Ty::Infer(InferTy::TypeVar(tv1)), Ty::Infer(InferTy::TypeVar(tv2))) | 915 | (Ty::Infer(InferTy::TypeVar(tv1)), Ty::Infer(InferTy::TypeVar(tv2))) |
984 | | (Ty::Infer(InferTy::IntVar(tv1)), Ty::Infer(InferTy::IntVar(tv2))) | 916 | | (Ty::Infer(InferTy::IntVar(tv1)), Ty::Infer(InferTy::IntVar(tv2))) |
985 | | (Ty::Infer(InferTy::FloatVar(tv1)), Ty::Infer(InferTy::FloatVar(tv2))) => { | 917 | | (Ty::Infer(InferTy::FloatVar(tv1)), Ty::Infer(InferTy::FloatVar(tv2))) => { |
@@ -994,8 +926,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { | |||
994 | | (Ty::Infer(InferTy::FloatVar(tv)), other) | 926 | | (Ty::Infer(InferTy::FloatVar(tv)), other) |
995 | | (other, Ty::Infer(InferTy::FloatVar(tv))) => { | 927 | | (other, Ty::Infer(InferTy::FloatVar(tv))) => { |
996 | // the type var is unknown since we tried to resolve it | 928 | // the type var is unknown since we tried to resolve it |
997 | self.var_unification_table | 929 | self.var_unification_table.union_value(*tv, TypeVarValue::Known(other.clone())); |
998 | .union_value(*tv, TypeVarValue::Known(other.clone())); | ||
999 | true | 930 | true |
1000 | } | 931 | } |
1001 | _ => false, | 932 | _ => false, |
@@ -1003,21 +934,15 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { | |||
1003 | } | 934 | } |
1004 | 935 | ||
1005 | fn new_type_var(&mut self) -> Ty { | 936 | fn new_type_var(&mut self) -> Ty { |
1006 | Ty::Infer(InferTy::TypeVar( | 937 | Ty::Infer(InferTy::TypeVar(self.var_unification_table.new_key(TypeVarValue::Unknown))) |
1007 | self.var_unification_table.new_key(TypeVarValue::Unknown), | ||
1008 | )) | ||
1009 | } | 938 | } |
1010 | 939 | ||
1011 | fn new_integer_var(&mut self) -> Ty { | 940 | fn new_integer_var(&mut self) -> Ty { |
1012 | Ty::Infer(InferTy::IntVar( | 941 | Ty::Infer(InferTy::IntVar(self.var_unification_table.new_key(TypeVarValue::Unknown))) |
1013 | self.var_unification_table.new_key(TypeVarValue::Unknown), | ||
1014 | )) | ||
1015 | } | 942 | } |
1016 | 943 | ||
1017 | fn new_float_var(&mut self) -> Ty { | 944 | fn new_float_var(&mut self) -> Ty { |
1018 | Ty::Infer(InferTy::FloatVar( | 945 | Ty::Infer(InferTy::FloatVar(self.var_unification_table.new_key(TypeVarValue::Unknown))) |
1019 | self.var_unification_table.new_key(TypeVarValue::Unknown), | ||
1020 | )) | ||
1021 | } | 946 | } |
1022 | 947 | ||
1023 | /// Replaces Ty::Unknown by a new type var, so we can maybe still infer it. | 948 | /// Replaces Ty::Unknown by a new type var, so we can maybe still infer it. |
@@ -1207,9 +1132,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { | |||
1207 | 1132 | ||
1208 | for subpat in subpats { | 1133 | for subpat in subpats { |
1209 | let matching_field = def.and_then(|it| it.field(self.db, &subpat.name)); | 1134 | let matching_field = def.and_then(|it| it.field(self.db, &subpat.name)); |
1210 | let expected_ty = matching_field | 1135 | let expected_ty = |
1211 | .map_or(Ty::Unknown, |field| field.ty(self.db)) | 1136 | matching_field.map_or(Ty::Unknown, |field| field.ty(self.db)).subst(&substs); |
1212 | .subst(&substs); | ||
1213 | self.infer_pat(subpat.pat, &expected_ty); | 1137 | self.infer_pat(subpat.pat, &expected_ty); |
1214 | } | 1138 | } |
1215 | 1139 | ||
@@ -1249,25 +1173,18 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { | |||
1249 | let subty = self.infer_pat(*pat, expectation); | 1173 | let subty = self.infer_pat(*pat, expectation); |
1250 | Ty::Ref(subty.into(), *mutability) | 1174 | Ty::Ref(subty.into(), *mutability) |
1251 | } | 1175 | } |
1252 | Pat::TupleStruct { | 1176 | Pat::TupleStruct { path: ref p, args: ref subpats } => { |
1253 | path: ref p, | 1177 | self.infer_tuple_struct_pat(p.as_ref(), subpats, expected) |
1254 | args: ref subpats, | 1178 | } |
1255 | } => self.infer_tuple_struct_pat(p.as_ref(), subpats, expected), | 1179 | Pat::Struct { path: ref p, args: ref fields } => { |
1256 | Pat::Struct { | 1180 | self.infer_struct_pat(p.as_ref(), fields, expected) |
1257 | path: ref p, | 1181 | } |
1258 | args: ref fields, | ||
1259 | } => self.infer_struct_pat(p.as_ref(), fields, expected), | ||
1260 | Pat::Path(path) => { | 1182 | Pat::Path(path) => { |
1261 | // TODO use correct resolver for the surrounding expression | 1183 | // TODO use correct resolver for the surrounding expression |
1262 | let resolver = self.resolver.clone(); | 1184 | let resolver = self.resolver.clone(); |
1263 | self.infer_path_expr(&resolver, &path) | 1185 | self.infer_path_expr(&resolver, &path).unwrap_or(Ty::Unknown) |
1264 | .unwrap_or(Ty::Unknown) | 1186 | } |
1265 | } | 1187 | Pat::Bind { mode, name: _name, subpat } => { |
1266 | Pat::Bind { | ||
1267 | mode, | ||
1268 | name: _name, | ||
1269 | subpat, | ||
1270 | } => { | ||
1271 | let subty = if let Some(subpat) = subpat { | 1188 | let subty = if let Some(subpat) = subpat { |
1272 | self.infer_pat(*subpat, expected) | 1189 | self.infer_pat(*subpat, expected) |
1273 | } else { | 1190 | } else { |
@@ -1294,11 +1211,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { | |||
1294 | let body = Arc::clone(&self.body); // avoid borrow checker problem | 1211 | let body = Arc::clone(&self.body); // avoid borrow checker problem |
1295 | let ty = match &body[tgt_expr] { | 1212 | let ty = match &body[tgt_expr] { |
1296 | Expr::Missing => Ty::Unknown, | 1213 | Expr::Missing => Ty::Unknown, |
1297 | Expr::If { | 1214 | Expr::If { condition, then_branch, else_branch } => { |
1298 | condition, | ||
1299 | then_branch, | ||
1300 | else_branch, | ||
1301 | } => { | ||
1302 | // if let is desugared to match, so this is always simple if | 1215 | // if let is desugared to match, so this is always simple if |
1303 | self.infer_expr(*condition, &Expectation::has_type(Ty::Bool)); | 1216 | self.infer_expr(*condition, &Expectation::has_type(Ty::Bool)); |
1304 | let then_ty = self.infer_expr(*then_branch, expected); | 1217 | let then_ty = self.infer_expr(*then_branch, expected); |
@@ -1325,21 +1238,13 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { | |||
1325 | self.infer_expr(*body, &Expectation::has_type(Ty::unit())); | 1238 | self.infer_expr(*body, &Expectation::has_type(Ty::unit())); |
1326 | Ty::unit() | 1239 | Ty::unit() |
1327 | } | 1240 | } |
1328 | Expr::For { | 1241 | Expr::For { iterable, body, pat } => { |
1329 | iterable, | ||
1330 | body, | ||
1331 | pat, | ||
1332 | } => { | ||
1333 | let _iterable_ty = self.infer_expr(*iterable, &Expectation::none()); | 1242 | let _iterable_ty = self.infer_expr(*iterable, &Expectation::none()); |
1334 | self.infer_pat(*pat, &Ty::Unknown); | 1243 | self.infer_pat(*pat, &Ty::Unknown); |
1335 | self.infer_expr(*body, &Expectation::has_type(Ty::unit())); | 1244 | self.infer_expr(*body, &Expectation::has_type(Ty::unit())); |
1336 | Ty::unit() | 1245 | Ty::unit() |
1337 | } | 1246 | } |
1338 | Expr::Lambda { | 1247 | Expr::Lambda { body, args, arg_types } => { |
1339 | body, | ||
1340 | args, | ||
1341 | arg_types, | ||
1342 | } => { | ||
1343 | assert_eq!(args.len(), arg_types.len()); | 1248 | assert_eq!(args.len(), arg_types.len()); |
1344 | 1249 | ||
1345 | for (arg_pat, arg_type) in args.iter().zip(arg_types.iter()) { | 1250 | for (arg_pat, arg_type) in args.iter().zip(arg_types.iter()) { |
@@ -1362,11 +1267,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { | |||
1362 | Ty::FnPtr(sig) => (sig.input.clone(), sig.output.clone()), | 1267 | Ty::FnPtr(sig) => (sig.input.clone(), sig.output.clone()), |
1363 | Ty::FnDef { substs, sig, .. } => { | 1268 | Ty::FnDef { substs, sig, .. } => { |
1364 | let ret_ty = sig.output.clone().subst(&substs); | 1269 | let ret_ty = sig.output.clone().subst(&substs); |
1365 | let param_tys = sig | 1270 | let param_tys = |
1366 | .input | 1271 | sig.input.iter().map(|ty| ty.clone().subst(&substs)).collect(); |
1367 | .iter() | ||
1368 | .map(|ty| ty.clone().subst(&substs)) | ||
1369 | .collect(); | ||
1370 | (param_tys, ret_ty) | 1272 | (param_tys, ret_ty) |
1371 | } | 1273 | } |
1372 | _ => { | 1274 | _ => { |
@@ -1381,11 +1283,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { | |||
1381 | } | 1283 | } |
1382 | ret_ty | 1284 | ret_ty |
1383 | } | 1285 | } |
1384 | Expr::MethodCall { | 1286 | Expr::MethodCall { receiver, args, method_name } => { |
1385 | receiver, | ||
1386 | args, | ||
1387 | method_name, | ||
1388 | } => { | ||
1389 | let receiver_ty = self.infer_expr(*receiver, &Expectation::none()); | 1287 | let receiver_ty = self.infer_expr(*receiver, &Expectation::none()); |
1390 | let resolved = receiver_ty.clone().lookup_method(self.db, method_name); | 1288 | let resolved = receiver_ty.clone().lookup_method(self.db, method_name); |
1391 | let method_ty = match resolved { | 1289 | let method_ty = match resolved { |
@@ -1399,11 +1297,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { | |||
1399 | let (expected_receiver_ty, param_tys, ret_ty) = match &method_ty { | 1297 | let (expected_receiver_ty, param_tys, ret_ty) = match &method_ty { |
1400 | Ty::FnPtr(sig) => { | 1298 | Ty::FnPtr(sig) => { |
1401 | if !sig.input.is_empty() { | 1299 | if !sig.input.is_empty() { |
1402 | ( | 1300 | (sig.input[0].clone(), sig.input[1..].to_vec(), sig.output.clone()) |
1403 | sig.input[0].clone(), | ||
1404 | sig.input[1..].to_vec(), | ||
1405 | sig.output.clone(), | ||
1406 | ) | ||
1407 | } else { | 1301 | } else { |
1408 | (Ty::Unknown, Vec::new(), sig.output.clone()) | 1302 | (Ty::Unknown, Vec::new(), sig.output.clone()) |
1409 | } | 1303 | } |
@@ -1469,11 +1363,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { | |||
1469 | } | 1363 | } |
1470 | Ty::Never | 1364 | Ty::Never |
1471 | } | 1365 | } |
1472 | Expr::StructLit { | 1366 | Expr::StructLit { path, fields, spread } => { |
1473 | path, | ||
1474 | fields, | ||
1475 | spread, | ||
1476 | } => { | ||
1477 | let (ty, def_id) = self.resolve_variant(path.as_ref()); | 1367 | let (ty, def_id) = self.resolve_variant(path.as_ref()); |
1478 | let substs = ty.substs().unwrap_or_else(Substs::empty); | 1368 | let substs = ty.substs().unwrap_or_else(Substs::empty); |
1479 | for field in fields { | 1369 | for field in fields { |
@@ -1497,14 +1387,12 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { | |||
1497 | let i = name.to_string().parse::<usize>().ok(); | 1387 | let i = name.to_string().parse::<usize>().ok(); |
1498 | i.and_then(|i| fields.get(i).cloned()) | 1388 | i.and_then(|i| fields.get(i).cloned()) |
1499 | } | 1389 | } |
1500 | Ty::Adt { | 1390 | Ty::Adt { def_id: AdtDef::Struct(s), ref substs, .. } => { |
1501 | def_id: AdtDef::Struct(s), | 1391 | s.field(self.db, name).map(|field| { |
1502 | ref substs, | 1392 | self.write_field_resolution(tgt_expr, field); |
1503 | .. | 1393 | field.ty(self.db).subst(substs) |
1504 | } => s.field(self.db, name).map(|field| { | 1394 | }) |
1505 | self.write_field_resolution(tgt_expr, field); | 1395 | } |
1506 | field.ty(self.db).subst(substs) | ||
1507 | }), | ||
1508 | _ => None, | 1396 | _ => None, |
1509 | }) | 1397 | }) |
1510 | .unwrap_or(Ty::Unknown); | 1398 | .unwrap_or(Ty::Unknown); |
@@ -1635,15 +1523,9 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { | |||
1635 | ) -> Ty { | 1523 | ) -> Ty { |
1636 | for stmt in statements { | 1524 | for stmt in statements { |
1637 | match stmt { | 1525 | match stmt { |
1638 | Statement::Let { | 1526 | Statement::Let { pat, type_ref, initializer } => { |
1639 | pat, | 1527 | let decl_ty = |
1640 | type_ref, | 1528 | type_ref.as_ref().map(|tr| self.make_ty(tr)).unwrap_or(Ty::Unknown); |
1641 | initializer, | ||
1642 | } => { | ||
1643 | let decl_ty = type_ref | ||
1644 | .as_ref() | ||
1645 | .map(|tr| self.make_ty(tr)) | ||
1646 | .unwrap_or(Ty::Unknown); | ||
1647 | let decl_ty = self.insert_type_vars(decl_ty); | 1529 | let decl_ty = self.insert_type_vars(decl_ty); |
1648 | let ty = if let Some(expr) = initializer { | 1530 | let ty = if let Some(expr) = initializer { |
1649 | let expr_ty = self.infer_expr(*expr, &Expectation::has_type(decl_ty)); | 1531 | let expr_ty = self.infer_expr(*expr, &Expectation::has_type(decl_ty)); |
@@ -1659,11 +1541,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { | |||
1659 | } | 1541 | } |
1660 | } | 1542 | } |
1661 | } | 1543 | } |
1662 | let ty = if let Some(expr) = tail { | 1544 | let ty = if let Some(expr) = tail { self.infer_expr(expr, expected) } else { Ty::unit() }; |
1663 | self.infer_expr(expr, expected) | ||
1664 | } else { | ||
1665 | Ty::unit() | ||
1666 | }; | ||
1667 | ty | 1545 | ty |
1668 | } | 1546 | } |
1669 | 1547 | ||
@@ -1678,10 +1556,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { | |||
1678 | } | 1556 | } |
1679 | 1557 | ||
1680 | fn infer_body(&mut self) { | 1558 | fn infer_body(&mut self) { |
1681 | self.infer_expr( | 1559 | self.infer_expr(self.body.body_expr(), &Expectation::has_type(self.return_ty.clone())); |
1682 | self.body.body_expr(), | ||
1683 | &Expectation::has_type(self.return_ty.clone()), | ||
1684 | ); | ||
1685 | } | 1560 | } |
1686 | } | 1561 | } |
1687 | 1562 | ||