From 12e3b4c70b5ef23b2fdfc197296d483680e125f9 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Fri, 8 Feb 2019 14:49:43 +0300 Subject: reformat the world --- crates/ra_hir/src/ty.rs | 249 ++++++++++++------------------------------------ 1 file changed, 62 insertions(+), 187 deletions(-) (limited to 'crates/ra_hir/src/ty.rs') 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 { match type_ref { TypeRef::Never => Ty::Never, TypeRef::Tuple(inner) => { - let inner_tys = inner - .iter() - .map(|tr| Ty::from_hir(db, resolver, tr)) - .collect::>(); + let inner_tys = + inner.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect::>(); Ty::Tuple(inner_tys.into()) } TypeRef::Path(path) => Ty::from_hir_path(db, resolver, path), @@ -330,17 +328,11 @@ impl Ty { } TypeRef::Placeholder => Ty::Unknown, TypeRef::Fn(params) => { - let mut inner_tys = params - .iter() - .map(|tr| Ty::from_hir(db, resolver, tr)) - .collect::>(); - let return_ty = inner_tys - .pop() - .expect("TypeRef::Fn should always have at least return type"); - let sig = FnSig { - input: inner_tys, - output: return_ty, - }; + let mut inner_tys = + params.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect::>(); + let return_ty = + inner_tys.pop().expect("TypeRef::Fn should always have at least return type"); + let sig = FnSig { input: inner_tys, output: return_ty }; Ty::FnPtr(Arc::new(sig)) } TypeRef::Error => Ty::Unknown, @@ -407,10 +399,7 @@ impl Ty { resolved: TypableDef, ) -> Substs { let mut substs = Vec::new(); - let last = path - .segments - .last() - .expect("path should have at least one segment"); + let last = path.segments.last().expect("path should have at least one segment"); let (def_generics, segment) = match resolved { TypableDef::Function(func) => (func.generic_params(db), last), TypableDef::Struct(s) => (s.generic_params(db), last), @@ -447,11 +436,8 @@ impl Ty { } // add placeholders for args that were not provided // TODO: handle defaults - let supplied_params = segment - .args_and_bindings - .as_ref() - .map(|ga| ga.args.len()) - .unwrap_or(0); + let supplied_params = + segment.args_and_bindings.as_ref().map(|ga| ga.args.len()).unwrap_or(0); for _ in supplied_params..def_generics.params.len() { substs.push(Ty::Unknown); } @@ -531,17 +517,8 @@ impl Ty { /// `Option` afterwards.) pub fn apply_substs(self, substs: Substs) -> Ty { match self { - Ty::Adt { def_id, name, .. } => Ty::Adt { - def_id, - name, - substs, - }, - Ty::FnDef { def, name, sig, .. } => Ty::FnDef { - def, - name, - sig, - substs, - }, + Ty::Adt { def_id, name, .. } => Ty::Adt { def_id, name, substs }, + Ty::FnDef { def, name, sig, .. } => Ty::FnDef { def, name, sig, substs }, _ => self, } } @@ -591,42 +568,25 @@ impl fmt::Display for Ty { if ts.len() == 1 { write!(f, "({},)", ts[0]) } else { - join(ts.iter()) - .surround_with("(", ")") - .separator(", ") - .to_fmt(f) + join(ts.iter()).surround_with("(", ")").separator(", ").to_fmt(f) } } Ty::FnPtr(sig) => { - join(sig.input.iter()) - .surround_with("fn(", ")") - .separator(", ") - .to_fmt(f)?; + join(sig.input.iter()).surround_with("fn(", ")").separator(", ").to_fmt(f)?; write!(f, " -> {}", sig.output) } - Ty::FnDef { - name, substs, sig, .. - } => { + Ty::FnDef { name, substs, sig, .. } => { write!(f, "fn {}", name)?; if substs.0.len() > 0 { - join(substs.0.iter()) - .surround_with("<", ">") - .separator(", ") - .to_fmt(f)?; + join(substs.0.iter()).surround_with("<", ">").separator(", ").to_fmt(f)?; } - join(sig.input.iter()) - .surround_with("(", ")") - .separator(", ") - .to_fmt(f)?; + join(sig.input.iter()).surround_with("(", ")").separator(", ").to_fmt(f)?; write!(f, " -> {}", sig.output) } Ty::Adt { name, substs, .. } => { write!(f, "{}", name)?; if substs.0.len() > 0 { - join(substs.0.iter()) - .surround_with("<", ">") - .separator(", ") - .to_fmt(f)?; + join(substs.0.iter()).surround_with("<", ">").separator(", ").to_fmt(f)?; } Ok(()) } @@ -646,31 +606,16 @@ fn type_for_fn(db: &impl HirDatabase, def: Function) -> Ty { let resolver = def.resolver(db); let generics = def.generic_params(db); let name = def.name(db); - let input = signature - .params() - .iter() - .map(|tr| Ty::from_hir(db, &resolver, tr)) - .collect::>(); + let input = + signature.params().iter().map(|tr| Ty::from_hir(db, &resolver, tr)).collect::>(); let output = Ty::from_hir(db, &resolver, signature.ret_type()); let sig = Arc::new(FnSig { input, output }); let substs = make_substs(&generics); - Ty::FnDef { - def, - sig, - name, - substs, - } + Ty::FnDef { def, sig, name, substs } } fn make_substs(generics: &GenericParams) -> Substs { - Substs( - generics - .params - .iter() - .map(|_p| Ty::Unknown) - .collect::>() - .into(), - ) + Substs(generics.params.iter().map(|_p| Ty::Unknown).collect::>().into()) } fn type_for_struct(db: &impl HirDatabase, s: Struct) -> Ty { @@ -935,11 +880,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { } fn unify_substs(&mut self, substs1: &Substs, substs2: &Substs) -> bool { - substs1 - .0 - .iter() - .zip(substs2.0.iter()) - .all(|(t1, t2)| self.unify(t1, t2)) + substs1.0.iter().zip(substs2.0.iter()).all(|(t1, t2)| self.unify(t1, t2)) } fn unify(&mut self, ty1: &Ty, ty2: &Ty) -> bool { @@ -961,25 +902,16 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { }, (Ty::Bool, _) | (Ty::Str, _) | (Ty::Never, _) | (Ty::Char, _) => ty1 == ty2, ( - Ty::Adt { - def_id: def_id1, - substs: substs1, - .. - }, - Ty::Adt { - def_id: def_id2, - substs: substs2, - .. - }, + Ty::Adt { def_id: def_id1, substs: substs1, .. }, + Ty::Adt { def_id: def_id2, substs: substs2, .. }, ) if def_id1 == def_id2 => self.unify_substs(substs1, substs2), (Ty::Slice(t1), Ty::Slice(t2)) => self.unify(t1, t2), (Ty::RawPtr(t1, m1), Ty::RawPtr(t2, m2)) if m1 == m2 => self.unify(t1, t2), (Ty::Ref(t1, m1), Ty::Ref(t2, m2)) if m1 == m2 => self.unify(t1, t2), (Ty::FnPtr(sig1), Ty::FnPtr(sig2)) if sig1 == sig2 => true, - (Ty::Tuple(ts1), Ty::Tuple(ts2)) if ts1.len() == ts2.len() => ts1 - .iter() - .zip(ts2.iter()) - .all(|(t1, t2)| self.unify(t1, t2)), + (Ty::Tuple(ts1), Ty::Tuple(ts2)) if ts1.len() == ts2.len() => { + ts1.iter().zip(ts2.iter()).all(|(t1, t2)| self.unify(t1, t2)) + } (Ty::Infer(InferTy::TypeVar(tv1)), Ty::Infer(InferTy::TypeVar(tv2))) | (Ty::Infer(InferTy::IntVar(tv1)), Ty::Infer(InferTy::IntVar(tv2))) | (Ty::Infer(InferTy::FloatVar(tv1)), Ty::Infer(InferTy::FloatVar(tv2))) => { @@ -994,8 +926,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { | (Ty::Infer(InferTy::FloatVar(tv)), other) | (other, Ty::Infer(InferTy::FloatVar(tv))) => { // the type var is unknown since we tried to resolve it - self.var_unification_table - .union_value(*tv, TypeVarValue::Known(other.clone())); + self.var_unification_table.union_value(*tv, TypeVarValue::Known(other.clone())); true } _ => false, @@ -1003,21 +934,15 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { } fn new_type_var(&mut self) -> Ty { - Ty::Infer(InferTy::TypeVar( - self.var_unification_table.new_key(TypeVarValue::Unknown), - )) + Ty::Infer(InferTy::TypeVar(self.var_unification_table.new_key(TypeVarValue::Unknown))) } fn new_integer_var(&mut self) -> Ty { - Ty::Infer(InferTy::IntVar( - self.var_unification_table.new_key(TypeVarValue::Unknown), - )) + Ty::Infer(InferTy::IntVar(self.var_unification_table.new_key(TypeVarValue::Unknown))) } fn new_float_var(&mut self) -> Ty { - Ty::Infer(InferTy::FloatVar( - self.var_unification_table.new_key(TypeVarValue::Unknown), - )) + Ty::Infer(InferTy::FloatVar(self.var_unification_table.new_key(TypeVarValue::Unknown))) } /// 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> { for subpat in subpats { let matching_field = def.and_then(|it| it.field(self.db, &subpat.name)); - let expected_ty = matching_field - .map_or(Ty::Unknown, |field| field.ty(self.db)) - .subst(&substs); + let expected_ty = + matching_field.map_or(Ty::Unknown, |field| field.ty(self.db)).subst(&substs); self.infer_pat(subpat.pat, &expected_ty); } @@ -1249,25 +1173,18 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { let subty = self.infer_pat(*pat, expectation); Ty::Ref(subty.into(), *mutability) } - Pat::TupleStruct { - path: ref p, - args: ref subpats, - } => self.infer_tuple_struct_pat(p.as_ref(), subpats, expected), - Pat::Struct { - path: ref p, - args: ref fields, - } => self.infer_struct_pat(p.as_ref(), fields, expected), + Pat::TupleStruct { path: ref p, args: ref subpats } => { + self.infer_tuple_struct_pat(p.as_ref(), subpats, expected) + } + Pat::Struct { path: ref p, args: ref fields } => { + self.infer_struct_pat(p.as_ref(), fields, expected) + } Pat::Path(path) => { // TODO use correct resolver for the surrounding expression let resolver = self.resolver.clone(); - self.infer_path_expr(&resolver, &path) - .unwrap_or(Ty::Unknown) - } - Pat::Bind { - mode, - name: _name, - subpat, - } => { + self.infer_path_expr(&resolver, &path).unwrap_or(Ty::Unknown) + } + Pat::Bind { mode, name: _name, subpat } => { let subty = if let Some(subpat) = subpat { self.infer_pat(*subpat, expected) } else { @@ -1294,11 +1211,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { let body = Arc::clone(&self.body); // avoid borrow checker problem let ty = match &body[tgt_expr] { Expr::Missing => Ty::Unknown, - Expr::If { - condition, - then_branch, - else_branch, - } => { + Expr::If { condition, then_branch, else_branch } => { // if let is desugared to match, so this is always simple if self.infer_expr(*condition, &Expectation::has_type(Ty::Bool)); let then_ty = self.infer_expr(*then_branch, expected); @@ -1325,21 +1238,13 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { self.infer_expr(*body, &Expectation::has_type(Ty::unit())); Ty::unit() } - Expr::For { - iterable, - body, - pat, - } => { + Expr::For { iterable, body, pat } => { let _iterable_ty = self.infer_expr(*iterable, &Expectation::none()); self.infer_pat(*pat, &Ty::Unknown); self.infer_expr(*body, &Expectation::has_type(Ty::unit())); Ty::unit() } - Expr::Lambda { - body, - args, - arg_types, - } => { + Expr::Lambda { body, args, arg_types } => { assert_eq!(args.len(), arg_types.len()); for (arg_pat, arg_type) in args.iter().zip(arg_types.iter()) { @@ -1362,11 +1267,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { Ty::FnPtr(sig) => (sig.input.clone(), sig.output.clone()), Ty::FnDef { substs, sig, .. } => { let ret_ty = sig.output.clone().subst(&substs); - let param_tys = sig - .input - .iter() - .map(|ty| ty.clone().subst(&substs)) - .collect(); + let param_tys = + sig.input.iter().map(|ty| ty.clone().subst(&substs)).collect(); (param_tys, ret_ty) } _ => { @@ -1381,11 +1283,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { } ret_ty } - Expr::MethodCall { - receiver, - args, - method_name, - } => { + Expr::MethodCall { receiver, args, method_name } => { let receiver_ty = self.infer_expr(*receiver, &Expectation::none()); let resolved = receiver_ty.clone().lookup_method(self.db, method_name); let method_ty = match resolved { @@ -1399,11 +1297,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { let (expected_receiver_ty, param_tys, ret_ty) = match &method_ty { Ty::FnPtr(sig) => { if !sig.input.is_empty() { - ( - sig.input[0].clone(), - sig.input[1..].to_vec(), - sig.output.clone(), - ) + (sig.input[0].clone(), sig.input[1..].to_vec(), sig.output.clone()) } else { (Ty::Unknown, Vec::new(), sig.output.clone()) } @@ -1469,11 +1363,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { } Ty::Never } - Expr::StructLit { - path, - fields, - spread, - } => { + Expr::StructLit { path, fields, spread } => { let (ty, def_id) = self.resolve_variant(path.as_ref()); let substs = ty.substs().unwrap_or_else(Substs::empty); for field in fields { @@ -1497,14 +1387,12 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { let i = name.to_string().parse::().ok(); i.and_then(|i| fields.get(i).cloned()) } - Ty::Adt { - def_id: AdtDef::Struct(s), - ref substs, - .. - } => s.field(self.db, name).map(|field| { - self.write_field_resolution(tgt_expr, field); - field.ty(self.db).subst(substs) - }), + Ty::Adt { def_id: AdtDef::Struct(s), ref substs, .. } => { + s.field(self.db, name).map(|field| { + self.write_field_resolution(tgt_expr, field); + field.ty(self.db).subst(substs) + }) + } _ => None, }) .unwrap_or(Ty::Unknown); @@ -1635,15 +1523,9 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { ) -> Ty { for stmt in statements { match stmt { - Statement::Let { - pat, - type_ref, - initializer, - } => { - let decl_ty = type_ref - .as_ref() - .map(|tr| self.make_ty(tr)) - .unwrap_or(Ty::Unknown); + Statement::Let { pat, type_ref, initializer } => { + let decl_ty = + type_ref.as_ref().map(|tr| self.make_ty(tr)).unwrap_or(Ty::Unknown); let decl_ty = self.insert_type_vars(decl_ty); let ty = if let Some(expr) = initializer { let expr_ty = self.infer_expr(*expr, &Expectation::has_type(decl_ty)); @@ -1659,11 +1541,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { } } } - let ty = if let Some(expr) = tail { - self.infer_expr(expr, expected) - } else { - Ty::unit() - }; + let ty = if let Some(expr) = tail { self.infer_expr(expr, expected) } else { Ty::unit() }; ty } @@ -1678,10 +1556,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { } fn infer_body(&mut self) { - self.infer_expr( - self.body.body_expr(), - &Expectation::has_type(self.return_ty.clone()), - ); + self.infer_expr(self.body.body_expr(), &Expectation::has_type(self.return_ty.clone())); } } -- cgit v1.2.3