Get rid of the terrible nesting in PathExpr inference

diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index 88bce19607fbd2030d7ccd58e45e5069642ac025..1d5473d17aeda28b9fee16f482229e18924525c7 100644 (file)
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -247,6 +247,19 @@ fn unify(&mut self, _ty1: &Ty, _ty2: &Ty) -> bool {
         unimplemented!()
     }
 
+    fn infer_path_expr(&mut self, expr: ast::PathExpr) -> Option<Ty> {
+        let p = expr.path()?;
+        if p.qualifier().is_none() {
+            let name = p.segment().and_then(|s| s.name_ref())?;
+            let scope_entry = self.scopes.resolve_local_name(name)?;
+            let ty = self.type_for.get(&scope_entry.ptr())?;
+            Some(ty.clone())
+        } else {
+            // TODO resolve path
+            Some(Ty::Unknown)
+        }
+    }
+
     fn infer_expr(&mut self, expr: ast::Expr) -> Ty {
         let ty = match expr {
             ast::Expr::IfExpr(e) => {
@@ -367,32 +380,7 @@ fn infer_expr(&mut self, expr: ast::Expr) -> Ty {
             }
             ast::Expr::TupleExpr(_e) => Ty::Unknown,
             ast::Expr::ArrayExpr(_e) => Ty::Unknown,
-            ast::Expr::PathExpr(e) => {
-                if let Some(p) = e.path() {
-                    if p.qualifier().is_none() {
-                        if let Some(name) = p.segment().and_then(|s| s.name_ref()) {
-                            let s = self.scopes.resolve_local_name(name);
-                            if let Some(scope_entry) = s {
-                                if let Some(ty) = self.type_for.get(&scope_entry.ptr()) {
-                                    ty.clone()
-                                } else {
-                                    // TODO introduce type variable?
-                                    Ty::Unknown
-                                }
-                            } else {
-                                Ty::Unknown
-                            }
-                        } else {
-                            Ty::Unknown
-                        }
-                    } else {
-                        // TODO resolve path
-                        Ty::Unknown
-                    }
-                } else {
-                    Ty::Unknown
-                }
-            }
+            ast::Expr::PathExpr(e) => self.infer_path_expr(e).unwrap_or(Ty::Unknown),
             ast::Expr::ContinueExpr(_e) => Ty::Never,
             ast::Expr::BreakExpr(_e) => Ty::Never,
             ast::Expr::ParenExpr(e) => {