7 files changed, 73 insertions, 528 deletions
diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs
index 53da7f0bf..ddf605111 100644
--- a/crates/ra_hir/src/expr.rs
+++ b/crates/ra_hir/src/expr.rs
@@ -6,35 +6,22 @@ pub(crate) mod validation;
 use std::{ops::Index, sync::Arc};
-use hir_def::{
+use ra_arena::{map::ArenaMap, Arena};
-    path::GenericArgs,
-    type_ref::{Mutability, TypeRef},
-};
-use ra_arena::{impl_arena_id, map::ArenaMap, Arena, RawId};
 use ra_syntax::{ast, AstPtr};
 use rustc_hash::FxHashMap;
-use crate::{
+use crate::{db::HirDatabase, DefWithBody, Either, HasSource, Resolver, Source};
-    db::HirDatabase,
-    ty::primitive::{UncertainFloatTy, UncertainIntTy},
-    DefWithBody, Either, HasSource, Name, Path, Resolver, Source,
-};
 pub use self::scope::ExprScopes;
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub use hir_def::expr::{
-pub struct ExprId(RawId);
+    ArithOp, Array, BinaryOp, BindingAnnotation, CmpOp, Expr, ExprId, Literal, LogicOp, MatchArm,
-impl_arena_id!(ExprId);
+    Ordering, Pat, PatId, RecordFieldPat, RecordLitField, Statement, UnaryOp,
+};
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct PatId(RawId);
-impl_arena_id!(PatId);
 /// The body of an item (function, const etc.).
 #[derive(Debug, Eq, PartialEq)]
 pub struct Body {
-    /// The def of the item this body belongs to
-    owner: DefWithBody,
    exprs: Arena<ExprId, Expr>,
    pats: Arena<PatId, Pat>,
    /// The patterns for the function's parameters. While the parameter types are
@@ -97,7 +84,7 @@ impl Body {
            }
        };
-        let (body, source_map) = lower::lower(db, def.resolver(db), file_id, def, params, body);
+        let (body, source_map) = lower::lower(db, def.resolver(db), file_id, params, body);
        (Arc::new(body), Arc::new(source_map))
    }
@@ -113,10 +100,6 @@ impl Body {
        self.body_expr
    }
-    pub fn owner(&self) -> DefWithBody {
-        self.owner
-    }
    pub fn exprs(&self) -> impl Iterator<Item = (ExprId, &Expr)> {
        self.exprs.iter()
    }
@@ -128,21 +111,21 @@ impl Body {
 // needs arbitrary_self_types to be a method... or maybe move to the def?
 pub(crate) fn resolver_for_expr(
-    body: Arc<Body>,
    db: &impl HirDatabase,
+    owner: DefWithBody,
    expr_id: ExprId,
 ) -> Resolver {
-    let scopes = db.expr_scopes(body.owner);
+    let scopes = db.expr_scopes(owner);
-    resolver_for_scope(body, db, scopes.scope_for(expr_id))
+    resolver_for_scope(db, owner, scopes.scope_for(expr_id))
 }
 pub(crate) fn resolver_for_scope(
-    body: Arc<Body>,
    db: &impl HirDatabase,
+    owner: DefWithBody,
    scope_id: Option<scope::ScopeId>,
 ) -> Resolver {
-    let mut r = body.owner.resolver(db);
+    let mut r = owner.resolver(db);
-    let scopes = db.expr_scopes(body.owner);
+    let scopes = db.expr_scopes(owner);
    let scope_chain = scopes.scope_chain(scope_id).collect::<Vec<_>>();
    for scope in scope_chain.into_iter().rev() {
        r = r.push_expr_scope(Arc::clone(&scopes), scope);
@@ -187,388 +170,3 @@ impl BodySourceMap {
        self.field_map[&(expr, field)]
    }
 }
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub enum Literal {
-    String(String),
-    ByteString(Vec<u8>),
-    Char(char),
-    Bool(bool),
-    Int(u64, UncertainIntTy),
-    Float(u64, UncertainFloatTy), // FIXME: f64 is not Eq
-}
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub enum Expr {
-    /// This is produced if syntax tree does not have a required expression piece.
-    Missing,
-    Path(Path),
-    If {
-        condition: ExprId,
-        then_branch: ExprId,
-        else_branch: Option<ExprId>,
-    },
-    Block {
-        statements: Vec<Statement>,
-        tail: Option<ExprId>,
-    },
-    Loop {
-        body: ExprId,
-    },
-    While {
-        condition: ExprId,
-        body: ExprId,
-    },
-    For {
-        iterable: ExprId,
-        pat: PatId,
-        body: ExprId,
-    },
-    Call {
-        callee: ExprId,
-        args: Vec<ExprId>,
-    },
-    MethodCall {
-        receiver: ExprId,
-        method_name: Name,
-        args: Vec<ExprId>,
-        generic_args: Option<GenericArgs>,
-    },
-    Match {
-        expr: ExprId,
-        arms: Vec<MatchArm>,
-    },
-    Continue,
-    Break {
-        expr: Option<ExprId>,
-    },
-    Return {
-        expr: Option<ExprId>,
-    },
-    RecordLit {
-        path: Option<Path>,
-        fields: Vec<RecordLitField>,
-        spread: Option<ExprId>,
-    },
-    Field {
-        expr: ExprId,
-        name: Name,
-    },
-    Await {
-        expr: ExprId,
-    },
-    Try {
-        expr: ExprId,
-    },
-    TryBlock {
-        body: ExprId,
-    },
-    Cast {
-        expr: ExprId,
-        type_ref: TypeRef,
-    },
-    Ref {
-        expr: ExprId,
-        mutability: Mutability,
-    },
-    Box {
-        expr: ExprId,
-    },
-    UnaryOp {
-        expr: ExprId,
-        op: UnaryOp,
-    },
-    BinaryOp {
-        lhs: ExprId,
-        rhs: ExprId,
-        op: Option<BinaryOp>,
-    },
-    Index {
-        base: ExprId,
-        index: ExprId,
-    },
-    Lambda {
-        args: Vec<PatId>,
-        arg_types: Vec<Option<TypeRef>>,
-        body: ExprId,
-    },
-    Tuple {
-        exprs: Vec<ExprId>,
-    },
-    Array(Array),
-    Literal(Literal),
-}
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub enum BinaryOp {
-    LogicOp(LogicOp),
-    ArithOp(ArithOp),
-    CmpOp(CmpOp),
-    Assignment { op: Option<ArithOp> },
-}
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub enum LogicOp {
-    And,
-    Or,
-}
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub enum CmpOp {
-    Eq { negated: bool },
-    Ord { ordering: Ordering, strict: bool },
-}
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub enum Ordering {
-    Less,
-    Greater,
-}
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub enum ArithOp {
-    Add,
-    Mul,
-    Sub,
-    Div,
-    Rem,
-    Shl,
-    Shr,
-    BitXor,
-    BitOr,
-    BitAnd,
-}
-pub use ra_syntax::ast::PrefixOp as UnaryOp;
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub enum Array {
-    ElementList(Vec<ExprId>),
-    Repeat { initializer: ExprId, repeat: ExprId },
-}
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub struct MatchArm {
-    pub pats: Vec<PatId>,
-    pub guard: Option<ExprId>,
-    pub expr: ExprId,
-}
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub struct RecordLitField {
-    pub name: Name,
-    pub expr: ExprId,
-}
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub enum Statement {
-    Let { pat: PatId, type_ref: Option<TypeRef>, initializer: Option<ExprId> },
-    Expr(ExprId),
-}
-impl Expr {
-    pub fn walk_child_exprs(&self, mut f: impl FnMut(ExprId)) {
-        match self {
-            Expr::Missing => {}
-            Expr::Path(_) => {}
-            Expr::If { condition, then_branch, else_branch } => {
-                f(*condition);
-                f(*then_branch);
-                if let Some(else_branch) = else_branch {
-                    f(*else_branch);
-                }
-            }
-            Expr::Block { statements, tail } => {
-                for stmt in statements {
-                    match stmt {
-                        Statement::Let { initializer, .. } => {
-                            if let Some(expr) = initializer {
-                                f(*expr);
-                            }
-                        }
-                        Statement::Expr(e) => f(*e),
-                    }
-                }
-                if let Some(expr) = tail {
-                    f(*expr);
-                }
-            }
-            Expr::TryBlock { body } => f(*body),
-            Expr::Loop { body } => f(*body),
-            Expr::While { condition, body } => {
-                f(*condition);
-                f(*body);
-            }
-            Expr::For { iterable, body, .. } => {
-                f(*iterable);
-                f(*body);
-            }
-            Expr::Call { callee, args } => {
-                f(*callee);
-                for arg in args {
-                    f(*arg);
-                }
-            }
-            Expr::MethodCall { receiver, args, .. } => {
-                f(*receiver);
-                for arg in args {
-                    f(*arg);
-                }
-            }
-            Expr::Match { expr, arms } => {
-                f(*expr);
-                for arm in arms {
-                    f(arm.expr);
-                }
-            }
-            Expr::Continue => {}
-            Expr::Break { expr } | Expr::Return { expr } => {
-                if let Some(expr) = expr {
-                    f(*expr);
-                }
-            }
-            Expr::RecordLit { fields, spread, .. } => {
-                for field in fields {
-                    f(field.expr);
-                }
-                if let Some(expr) = spread {
-                    f(*expr);
-                }
-            }
-            Expr::Lambda { body, .. } => {
-                f(*body);
-            }
-            Expr::BinaryOp { lhs, rhs, .. } => {
-                f(*lhs);
-                f(*rhs);
-            }
-            Expr::Index { base, index } => {
-                f(*base);
-                f(*index);
-            }
-            Expr::Field { expr, .. }
-            | Expr::Await { expr }
-            | Expr::Try { expr }
-            | Expr::Cast { expr, .. }
-            | Expr::Ref { expr, .. }
-            | Expr::UnaryOp { expr, .. }
-            | Expr::Box { expr } => {
-                f(*expr);
-            }
-            Expr::Tuple { exprs } => {
-                for expr in exprs {
-                    f(*expr);
-                }
-            }
-            Expr::Array(a) => match a {
-                Array::ElementList(exprs) => {
-                    for expr in exprs {
-                        f(*expr);
-                    }
-                }
-                Array::Repeat { initializer, repeat } => {
-                    f(*initializer);
-                    f(*repeat)
-                }
-            },
-            Expr::Literal(_) => {}
-        }
-    }
-}
-/// Explicit binding annotations given in the HIR for a binding. Note
-/// that this is not the final binding *mode* that we infer after type
-/// inference.
-#[derive(Clone, PartialEq, Eq, Debug, Copy)]
-pub enum BindingAnnotation {
-    /// No binding annotation given: this means that the final binding mode
-    /// will depend on whether we have skipped through a `&` reference
-    /// when matching. For example, the `x` in `Some(x)` will have binding
-    /// mode `None`; if you do `let Some(x) = &Some(22)`, it will
-    /// ultimately be inferred to be by-reference.
-    Unannotated,
-    /// Annotated with `mut x` -- could be either ref or not, similar to `None`.
-    Mutable,
-    /// Annotated as `ref`, like `ref x`
-    Ref,
-    /// Annotated as `ref mut x`.
-    RefMut,
-}
-impl BindingAnnotation {
-    fn new(is_mutable: bool, is_ref: bool) -> Self {
-        match (is_mutable, is_ref) {
-            (true, true) => BindingAnnotation::RefMut,
-            (false, true) => BindingAnnotation::Ref,
-            (true, false) => BindingAnnotation::Mutable,
-            (false, false) => BindingAnnotation::Unannotated,
-        }
-    }
-}
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub struct RecordFieldPat {
-    pub(crate) name: Name,
-    pub(crate) pat: PatId,
-}
-/// Close relative to rustc's hir::PatKind
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub enum Pat {
-    Missing,
-    Wild,
-    Tuple(Vec<PatId>),
-    Record {
-        path: Option<Path>,
-        args: Vec<RecordFieldPat>,
-        // FIXME: 'ellipsis' option
-    },
-    Range {
-        start: ExprId,
-        end: ExprId,
-    },
-    Slice {
-        prefix: Vec<PatId>,
-        rest: Option<PatId>,
-        suffix: Vec<PatId>,
-    },
-    Path(Path),
-    Lit(ExprId),
-    Bind {
-        mode: BindingAnnotation,
-        name: Name,
-        subpat: Option<PatId>,
-    },
-    TupleStruct {
-        path: Option<Path>,
-        args: Vec<PatId>,
-    },
-    Ref {
-        pat: PatId,
-        mutability: Mutability,
-    },
-}
-impl Pat {
-    pub fn walk_child_pats(&self, mut f: impl FnMut(PatId)) {
-        match self {
-            Pat::Range { .. } | Pat::Lit(..) | Pat::Path(..) | Pat::Wild | Pat::Missing => {}
-            Pat::Bind { subpat, .. } => {
-                subpat.iter().copied().for_each(f);
-            }
-            Pat::Tuple(args) | Pat::TupleStruct { args, .. } => {
-                args.iter().copied().for_each(f);
-            }
-            Pat::Ref { pat, .. } => f(*pat),
-            Pat::Slice { prefix, rest, suffix } => {
-                let total_iter = prefix.iter().chain(rest.iter()).chain(suffix.iter());
-                total_iter.copied().for_each(f);
-            }
-            Pat::Record { args, .. } => {
-                args.iter().map(|f| f.pat).for_each(f);
-            }
-        }
-    }
-}
diff --git a/crates/ra_hir/src/expr/lower.rs b/crates/ra_hir/src/expr/lower.rs
index 6463dd65e..adc68b23c 100644
--- a/crates/ra_hir/src/expr/lower.rs
+++ b/crates/ra_hir/src/expr/lower.rs
@@ -1,6 +1,10 @@
 //! FIXME: write short doc here
-use hir_def::{path::GenericArgs, type_ref::TypeRef};
+use hir_def::{
+    builtin_type::{BuiltinFloat, BuiltinInt},
+    path::GenericArgs,
+    type_ref::TypeRef,
+};
 use hir_expand::{
    hygiene::Hygiene,
    name::{self, AsName, Name},
@@ -16,22 +20,19 @@ use ra_syntax::{
 use test_utils::tested_by;
 use crate::{
-    db::HirDatabase,
+    db::HirDatabase, AstId, Either, HirFileId, MacroCallLoc, MacroFileKind, Mutability, Path,
-    ty::primitive::{FloatTy, IntTy, UncertainFloatTy, UncertainIntTy},
+    Resolver, Source,
-    AstId, DefWithBody, Either, HirFileId, MacroCallLoc, MacroFileKind, Mutability, Path, Resolver,
-    Source,
 };
 use super::{
-    ArithOp, Array, BinaryOp, BindingAnnotation, Body, BodySourceMap, CmpOp, Expr, ExprId, Literal,
+    Array, BinaryOp, BindingAnnotation, Body, BodySourceMap, Expr, ExprId, Literal, MatchArm, Pat,
-    LogicOp, MatchArm, Ordering, Pat, PatId, PatPtr, RecordFieldPat, RecordLitField, Statement,
+    PatId, PatPtr, RecordFieldPat, RecordLitField, Statement,
 };
 pub(super) fn lower(
    db: &impl HirDatabase,
    resolver: Resolver,
    file_id: HirFileId,
-    owner: DefWithBody,
    params: Option<ast::ParamList>,
    body: Option<ast::Expr>,
 ) -> (Body, BodySourceMap) {
@@ -42,11 +43,10 @@ pub(super) fn lower(
        current_file_id: file_id,
        source_map: BodySourceMap::default(),
        body: Body {
-            owner,
            exprs: Arena::default(),
            pats: Arena::default(),
            params: Vec::new(),
-            body_expr: ExprId((!0).into()),
+            body_expr: ExprId::dummy(),
        },
    }
    .collect(params, body)
@@ -423,28 +423,18 @@ where
            ast::Expr::Literal(e) => {
                let lit = match e.kind() {
                    LiteralKind::IntNumber { suffix } => {
-                        let known_name = suffix
+                        let known_name = suffix.and_then(|it| BuiltinInt::from_suffix(&it));
-                            .and_then(|it| IntTy::from_suffix(&it).map(UncertainIntTy::Known));
-                        Literal::Int(
+                        Literal::Int(Default::default(), known_name)
-                            Default::default(),
-                            known_name.unwrap_or(UncertainIntTy::Unknown),
-                        )
                    }
                    LiteralKind::FloatNumber { suffix } => {
-                        let known_name = suffix
+                        let known_name = suffix.and_then(|it| BuiltinFloat::from_suffix(&it));
-                            .and_then(|it| FloatTy::from_suffix(&it).map(UncertainFloatTy::Known));
-                        Literal::Float(
+                        Literal::Float(Default::default(), known_name)
-                            Default::default(),
-                            known_name.unwrap_or(UncertainFloatTy::Unknown),
-                        )
                    }
                    LiteralKind::ByteString => Literal::ByteString(Default::default()),
                    LiteralKind::String => Literal::String(Default::default()),
-                    LiteralKind::Byte => {
+                    LiteralKind::Byte => Literal::Int(Default::default(), Some(BuiltinInt::U8)),
-                        Literal::Int(Default::default(), UncertainIntTy::Known(IntTy::u8()))
-                    }
                    LiteralKind::Bool => Literal::Bool(Default::default()),
                    LiteralKind::Char => Literal::Char(Default::default()),
                };
@@ -601,47 +591,3 @@ where
        Path::from_src(path, &hygiene)
    }
 }
-impl From<ast::BinOp> for BinaryOp {
-    fn from(ast_op: ast::BinOp) -> Self {
-        match ast_op {
-            ast::BinOp::BooleanOr => BinaryOp::LogicOp(LogicOp::Or),
-            ast::BinOp::BooleanAnd => BinaryOp::LogicOp(LogicOp::And),
-            ast::BinOp::EqualityTest => BinaryOp::CmpOp(CmpOp::Eq { negated: false }),
-            ast::BinOp::NegatedEqualityTest => BinaryOp::CmpOp(CmpOp::Eq { negated: true }),
-            ast::BinOp::LesserEqualTest => {
-                BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Less, strict: false })
-            }
-            ast::BinOp::GreaterEqualTest => {
-                BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Greater, strict: false })
-            }
-            ast::BinOp::LesserTest => {
-                BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Less, strict: true })
-            }
-            ast::BinOp::GreaterTest => {
-                BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Greater, strict: true })
-            }
-            ast::BinOp::Addition => BinaryOp::ArithOp(ArithOp::Add),
-            ast::BinOp::Multiplication => BinaryOp::ArithOp(ArithOp::Mul),
-            ast::BinOp::Subtraction => BinaryOp::ArithOp(ArithOp::Sub),
-            ast::BinOp::Division => BinaryOp::ArithOp(ArithOp::Div),
-            ast::BinOp::Remainder => BinaryOp::ArithOp(ArithOp::Rem),
-            ast::BinOp::LeftShift => BinaryOp::ArithOp(ArithOp::Shl),
-            ast::BinOp::RightShift => BinaryOp::ArithOp(ArithOp::Shr),
-            ast::BinOp::BitwiseXor => BinaryOp::ArithOp(ArithOp::BitXor),
-            ast::BinOp::BitwiseOr => BinaryOp::ArithOp(ArithOp::BitOr),
-            ast::BinOp::BitwiseAnd => BinaryOp::ArithOp(ArithOp::BitAnd),
-            ast::BinOp::Assignment => BinaryOp::Assignment { op: None },
-            ast::BinOp::AddAssign => BinaryOp::Assignment { op: Some(ArithOp::Add) },
-            ast::BinOp::DivAssign => BinaryOp::Assignment { op: Some(ArithOp::Div) },
-            ast::BinOp::MulAssign => BinaryOp::Assignment { op: Some(ArithOp::Mul) },
-            ast::BinOp::RemAssign => BinaryOp::Assignment { op: Some(ArithOp::Rem) },
-            ast::BinOp::ShlAssign => BinaryOp::Assignment { op: Some(ArithOp::Shl) },
-            ast::BinOp::ShrAssign => BinaryOp::Assignment { op: Some(ArithOp::Shr) },
-            ast::BinOp::SubAssign => BinaryOp::Assignment { op: Some(ArithOp::Sub) },
-            ast::BinOp::BitOrAssign => BinaryOp::Assignment { op: Some(ArithOp::BitOr) },
-            ast::BinOp::BitAndAssign => BinaryOp::Assignment { op: Some(ArithOp::BitAnd) },
-            ast::BinOp::BitXorAssign => BinaryOp::Assignment { op: Some(ArithOp::BitXor) },
-        }
-    }
-}
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index fe4211819..f28e9c931 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -150,7 +150,7 @@ impl SourceAnalyzer {
                None => scope_for(&scopes, &source_map, &node),
                Some(offset) => scope_for_offset(&scopes, &source_map, file_id.into(), offset),
            };
-            let resolver = expr::resolver_for_scope(def.body(db), db, scope);
+            let resolver = expr::resolver_for_scope(db, def, scope);
            SourceAnalyzer {
                resolver,
                body_owner: Some(def),
diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index 2370e8d4f..f17c6c614 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -43,7 +43,7 @@ use crate::{
    expr::{BindingAnnotation, Body, ExprId, PatId},
    resolve::{Resolver, TypeNs},
    ty::infer::diagnostics::InferenceDiagnostic,
-    Adt, AssocItem, ConstData, DefWithBody, FnData, Function, HasBody, Path, StructField,
+    Adt, AssocItem, ConstData, DefWithBody, FnData, Function, Path, StructField,
 };
 macro_rules! ty_app {
@@ -64,9 +64,8 @@ mod coerce;
 /// The entry point of type inference.
 pub fn infer_query(db: &impl HirDatabase, def: DefWithBody) -> Arc<InferenceResult> {
    let _p = profile("infer_query");
-    let body = def.body(db);
    let resolver = def.resolver(db);
-    let mut ctx = InferenceContext::new(db, body, resolver);
+    let mut ctx = InferenceContext::new(db, def, resolver);
    match def {
        DefWithBody::Const(ref c) => ctx.collect_const(&c.data(db)),
@@ -187,6 +186,7 @@ impl Index<PatId> for InferenceResult {
 #[derive(Clone, Debug)]
 struct InferenceContext<'a, D: HirDatabase> {
    db: &'a D,
+    owner: DefWithBody,
    body: Arc<Body>,
    resolver: Resolver,
    var_unification_table: InPlaceUnificationTable<TypeVarId>,
@@ -204,7 +204,7 @@ struct InferenceContext<'a, D: HirDatabase> {
 }
 impl<'a, D: HirDatabase> InferenceContext<'a, D> {
-    fn new(db: &'a D, body: Arc<Body>, resolver: Resolver) -> Self {
+    fn new(db: &'a D, owner: DefWithBody, resolver: Resolver) -> Self {
        InferenceContext {
            result: InferenceResult::default(),
            var_unification_table: InPlaceUnificationTable::new(),
@@ -213,7 +213,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            trait_env: lower::trait_env(db, &resolver),
            coerce_unsized_map: Self::init_coerce_unsized_map(db, &resolver),
            db,
-            body,
+            owner,
+            body: db.body(owner),
            resolver,
        }
    }
diff --git a/crates/ra_hir/src/ty/infer/expr.rs b/crates/ra_hir/src/ty/infer/expr.rs
index 4af1d65ee..c6802487a 100644
--- a/crates/ra_hir/src/ty/infer/expr.rs
+++ b/crates/ra_hir/src/ty/infer/expr.rs
@@ -130,10 +130,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                    TypeCtor::FnPtr { num_args: sig_tys.len() as u16 - 1 },
                    Substs(sig_tys.into()),
                );
-                let closure_ty = Ty::apply_one(
+                let closure_ty =
-                    TypeCtor::Closure { def: self.body.owner(), expr: tgt_expr },
+                    Ty::apply_one(TypeCtor::Closure { def: self.owner, expr: tgt_expr }, sig_ty);
-                    sig_ty,
-                );
                // Eagerly try to relate the closure type with the expected
                // type, otherwise we often won't have enough information to
@@ -184,7 +182,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            }
            Expr::Path(p) => {
                // FIXME this could be more efficient...
-                let resolver = expr::resolver_for_expr(self.body.clone(), self.db, tgt_expr);
+                let resolver = expr::resolver_for_expr(self.db, self.owner, tgt_expr);
                self.infer_path(&resolver, p, tgt_expr.into()).unwrap_or(Ty::Unknown)
            }
            Expr::Continue => Ty::simple(TypeCtor::Never),
@@ -452,8 +450,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                    Ty::apply_one(TypeCtor::Ref(Mutability::Shared), slice_type)
                }
                Literal::Char(..) => Ty::simple(TypeCtor::Char),
-                Literal::Int(_v, ty) => Ty::simple(TypeCtor::Int(*ty)),
+                Literal::Int(_v, ty) => Ty::simple(TypeCtor::Int((*ty).into())),
-                Literal::Float(_v, ty) => Ty::simple(TypeCtor::Float(*ty)),
+                Literal::Float(_v, ty) => Ty::simple(TypeCtor::Float((*ty).into())),
            },
        };
        // use a new type variable if we got Ty::Unknown here
diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs
index 52d24e24d..1832fcf50 100644
--- a/crates/ra_hir/src/ty/lower.rs
+++ b/crates/ra_hir/src/ty/lower.rs
@@ -25,7 +25,7 @@ use crate::{
    generics::{GenericDef, WherePredicate},
    resolve::{Resolver, TypeNs},
    ty::{
-        primitive::{FloatTy, IntTy},
+        primitive::{FloatTy, IntTy, UncertainFloatTy, UncertainIntTy},
        Adt,
    },
    util::make_mut_slice,
@@ -657,13 +657,41 @@ fn type_for_builtin(def: BuiltinType) -> Ty {
        BuiltinType::Char => TypeCtor::Char,
        BuiltinType::Bool => TypeCtor::Bool,
        BuiltinType::Str => TypeCtor::Str,
-        BuiltinType::Int(BuiltinInt { signedness, bitness }) => {
+        BuiltinType::Int(t) => TypeCtor::Int(IntTy::from(t).into()),
-            TypeCtor::Int(IntTy { signedness, bitness }.into())
+        BuiltinType::Float(t) => TypeCtor::Float(FloatTy::from(t).into()),
-        }
-        BuiltinType::Float(BuiltinFloat { bitness }) => TypeCtor::Float(FloatTy { bitness }.into()),
    })
 }
+impl From<BuiltinInt> for IntTy {
+    fn from(t: BuiltinInt) -> Self {
+        IntTy { signedness: t.signedness, bitness: t.bitness }
+    }
+}
+impl From<BuiltinFloat> for FloatTy {
+    fn from(t: BuiltinFloat) -> Self {
+        FloatTy { bitness: t.bitness }
+    }
+}
+impl From<Option<BuiltinInt>> for UncertainIntTy {
+    fn from(t: Option<BuiltinInt>) -> Self {
+        match t {
+            None => UncertainIntTy::Unknown,
+            Some(t) => UncertainIntTy::Known(t.into()),
+        }
+    }
+}
+impl From<Option<BuiltinFloat>> for UncertainFloatTy {
+    fn from(t: Option<BuiltinFloat>) -> Self {
+        match t {
+            None => UncertainFloatTy::Unknown,
+            Some(t) => UncertainFloatTy::Known(t.into()),
+        }
+    }
+}
 fn fn_sig_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> FnSig {
    let struct_data = db.struct_data(def.id.into());
    let fields = match struct_data.variant_data.fields() {
diff --git a/crates/ra_hir/src/ty/primitive.rs b/crates/ra_hir/src/ty/primitive.rs
index 1749752f1..7362de4c3 100644
--- a/crates/ra_hir/src/ty/primitive.rs
+++ b/crates/ra_hir/src/ty/primitive.rs
@@ -129,24 +129,6 @@ impl IntTy {
            (Signedness::Unsigned, IntBitness::X128) => "u128",
        }
    }
-    pub(crate) fn from_suffix(suffix: &str) -> Option<IntTy> {
-        match suffix {
-            "isize" => Some(IntTy::isize()),
-            "i8" => Some(IntTy::i8()),
-            "i16" => Some(IntTy::i16()),
-            "i32" => Some(IntTy::i32()),
-            "i64" => Some(IntTy::i64()),
-            "i128" => Some(IntTy::i128()),
-            "usize" => Some(IntTy::usize()),
-            "u8" => Some(IntTy::u8()),
-            "u16" => Some(IntTy::u16()),
-            "u32" => Some(IntTy::u32()),
-            "u64" => Some(IntTy::u64()),
-            "u128" => Some(IntTy::u128()),
-            _ => None,
-        }
-    }
 }
 #[derive(Copy, Clone, PartialEq, Eq, Hash)]
@@ -181,12 +163,4 @@ impl FloatTy {
            FloatBitness::X64 => "f64",
        }
    }
-    pub(crate) fn from_suffix(suffix: &str) -> Option<FloatTy> {
-        match suffix {
-            "f32" => Some(FloatTy::f32()),
-            "f64" => Some(FloatTy::f64()),
-            _ => None,
-        }
-    }
 }