9 files changed, 114 insertions, 106 deletions
diff --git a/crates/ra_hir/src/ty/autoderef.rs b/crates/ra_hir/src/ty/autoderef.rs
index 3645ee831..872a4517d 100644
--- a/crates/ra_hir/src/ty/autoderef.rs
+++ b/crates/ra_hir/src/ty/autoderef.rs
@@ -9,7 +9,7 @@ use hir_expand::name;
 use log::{info, warn};
 use super::{traits::Solution, Canonical, Substs, Ty, TypeWalk};
-use crate::{db::HirDatabase, HasGenericParams, Resolver};
+use crate::{db::HirDatabase, generics::HasGenericParams, Resolver};
 const AUTODEREF_RECURSION_LIMIT: usize = 10;
diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index 2370e8d4f..c35378cc4 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -31,10 +31,10 @@ use ra_prof::profile;
 use test_utils::tested_by;
 use super::{
-    lower, primitive,
+    lower,
    traits::{Guidance, Obligation, ProjectionPredicate, Solution},
    ApplicationTy, InEnvironment, ProjectionTy, Substs, TraitEnvironment, TraitRef, Ty, TypableDef,
-    TypeCtor, TypeWalk,
+    TypeCtor, TypeWalk, Uncertain,
 };
 use crate::{
    adt::VariantDef,
@@ -43,7 +43,8 @@ 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, FloatTy, FnData, Function, HasBody, IntTy, Path,
+    StructField,
 };
 macro_rules! ty_app {
@@ -64,9 +65,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 +187,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 +205,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 +214,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: owner.body(db),
            resolver,
        }
    }
@@ -357,14 +359,12 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
    fn insert_type_vars_shallow(&mut self, ty: Ty) -> Ty {
        match ty {
            Ty::Unknown => self.new_type_var(),
-            Ty::Apply(ApplicationTy {
+            Ty::Apply(ApplicationTy { ctor: TypeCtor::Int(Uncertain::Unknown), .. }) => {
-                ctor: TypeCtor::Int(primitive::UncertainIntTy::Unknown),
+                self.new_integer_var()
-                ..
+            }
-            }) => self.new_integer_var(),
+            Ty::Apply(ApplicationTy { ctor: TypeCtor::Float(Uncertain::Unknown), .. }) => {
-            Ty::Apply(ApplicationTy {
+                self.new_float_var()
-                ctor: TypeCtor::Float(primitive::UncertainFloatTy::Unknown),
+            }
-                ..
-            }) => self.new_float_var(),
            _ => ty,
        }
    }
@@ -683,12 +683,8 @@ impl InferTy {
    fn fallback_value(self) -> Ty {
        match self {
            InferTy::TypeVar(..) => Ty::Unknown,
-            InferTy::IntVar(..) => {
+            InferTy::IntVar(..) => Ty::simple(TypeCtor::Int(Uncertain::Known(IntTy::i32()))),
-                Ty::simple(TypeCtor::Int(primitive::UncertainIntTy::Known(primitive::IntTy::i32())))
+            InferTy::FloatVar(..) => Ty::simple(TypeCtor::Float(Uncertain::Known(FloatTy::f64()))),
-            }
-            InferTy::FloatVar(..) => Ty::simple(TypeCtor::Float(
-                primitive::UncertainFloatTy::Known(primitive::FloatTy::f64()),
-            )),
            InferTy::MaybeNeverTypeVar(..) => Ty::simple(TypeCtor::Never),
        }
    }
diff --git a/crates/ra_hir/src/ty/infer/expr.rs b/crates/ra_hir/src/ty/infer/expr.rs
index 4af1d65ee..5e68a1678 100644
--- a/crates/ra_hir/src/ty/infer/expr.rs
+++ b/crates/ra_hir/src/ty/infer/expr.rs
@@ -3,7 +3,10 @@
 use std::iter::{repeat, repeat_with};
 use std::sync::Arc;
-use hir_def::path::{GenericArg, GenericArgs};
+use hir_def::{
+    builtin_type::Signedness,
+    path::{GenericArg, GenericArgs},
+};
 use hir_expand::name;
 use super::{BindingMode, Expectation, InferenceContext, InferenceDiagnostic, TypeMismatch};
@@ -12,8 +15,9 @@ use crate::{
    expr::{self, Array, BinaryOp, Expr, ExprId, Literal, Statement, UnaryOp},
    generics::{GenericParams, HasGenericParams},
    ty::{
-        autoderef, method_resolution, op, primitive, CallableDef, InferTy, Mutability, Namespace,
+        autoderef, method_resolution, op, CallableDef, InferTy, IntTy, Mutability, Namespace,
        Obligation, ProjectionPredicate, ProjectionTy, Substs, TraitRef, Ty, TypeCtor, TypeWalk,
+        Uncertain,
    },
    Adt, Name,
 };
@@ -130,10 +134,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 +186,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),
@@ -339,13 +341,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                    UnaryOp::Neg => {
                        match &inner_ty {
                            Ty::Apply(a_ty) => match a_ty.ctor {
-                                TypeCtor::Int(primitive::UncertainIntTy::Unknown)
+                                TypeCtor::Int(Uncertain::Unknown)
-                                | TypeCtor::Int(primitive::UncertainIntTy::Known(
+                                | TypeCtor::Int(Uncertain::Known(IntTy {
-                                    primitive::IntTy {
+                                    signedness: Signedness::Signed,
-                                        signedness: primitive::Signedness::Signed,
+                                    ..
-                                        ..
+                                }))
-                                    },
-                                ))
                                | TypeCtor::Float(..) => inner_ty,
                                _ => Ty::Unknown,
                            },
@@ -430,9 +430,9 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                        );
                        self.infer_expr(
                            *repeat,
-                            &Expectation::has_type(Ty::simple(TypeCtor::Int(
+                            &Expectation::has_type(Ty::simple(TypeCtor::Int(Uncertain::Known(
-                                primitive::UncertainIntTy::Known(primitive::IntTy::usize()),
+                                IntTy::usize(),
-                            ))),
+                            )))),
                        );
                    }
                }
@@ -445,15 +445,13 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                    Ty::apply_one(TypeCtor::Ref(Mutability::Shared), Ty::simple(TypeCtor::Str))
                }
                Literal::ByteString(..) => {
-                    let byte_type = Ty::simple(TypeCtor::Int(primitive::UncertainIntTy::Known(
+                    let byte_type = Ty::simple(TypeCtor::Int(Uncertain::Known(IntTy::u8())));
-                        primitive::IntTy::u8(),
-                    )));
                    let slice_type = Ty::apply_one(TypeCtor::Slice, byte_type);
                    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/infer/path.rs b/crates/ra_hir/src/ty/infer/path.rs
index 865ced5a1..31ca675aa 100644
--- a/crates/ra_hir/src/ty/infer/path.rs
+++ b/crates/ra_hir/src/ty/infer/path.rs
@@ -5,9 +5,10 @@ use hir_def::path::PathSegment;
 use super::{ExprOrPatId, InferenceContext, TraitRef};
 use crate::{
    db::HirDatabase,
+    generics::HasGenericParams,
    resolve::{ResolveValueResult, Resolver, TypeNs, ValueNs},
    ty::{method_resolution, Namespace, Substs, Ty, TypableDef, TypeWalk},
-    AssocItem, Container, HasGenericParams, Name, Path,
+    AssocItem, Container, Name, Path,
 };
 impl<'a, D: HirDatabase> InferenceContext<'a, D> {
diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs
index 1fed5025e..de3c56097 100644
--- a/crates/ra_hir/src/ty/lower.rs
+++ b/crates/ra_hir/src/ty/lower.rs
@@ -9,7 +9,7 @@ use std::iter;
 use std::sync::Arc;
 use hir_def::{
-    builtin_type::BuiltinType,
+    builtin_type::{BuiltinFloat, BuiltinInt, BuiltinType},
    path::{GenericArg, PathSegment},
    type_ref::{TypeBound, TypeRef},
 };
@@ -25,7 +25,7 @@ use crate::{
    generics::{GenericDef, WherePredicate},
    resolve::{Resolver, TypeNs},
    ty::{
-        primitive::{FloatTy, IntTy},
+        primitive::{FloatTy, IntTy, Uncertain},
        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 { 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 { 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 Uncertain<IntTy> {
+    fn from(t: Option<BuiltinInt>) -> Self {
+        match t {
+            None => Uncertain::Unknown,
+            Some(t) => Uncertain::Known(t.into()),
+        }
+    }
+}
+impl From<Option<BuiltinFloat>> for Uncertain<FloatTy> {
+    fn from(t: Option<BuiltinFloat>) -> Self {
+        match t {
+            None => Uncertain::Unknown,
+            Some(t) => Uncertain::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/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs
index 8c3d32d09..eb5ca6769 100644
--- a/crates/ra_hir/src/ty/method_resolution.rs
+++ b/crates/ra_hir/src/ty/method_resolution.rs
@@ -8,16 +8,17 @@ use arrayvec::ArrayVec;
 use hir_def::CrateModuleId;
 use rustc_hash::FxHashMap;
-use super::{autoderef, lower, Canonical, InEnvironment, TraitEnvironment, TraitRef};
 use crate::{
    db::HirDatabase,
    impl_block::{ImplBlock, ImplId},
    resolve::Resolver,
-    ty::primitive::{FloatBitness, UncertainFloatTy, UncertainIntTy},
+    ty::primitive::{FloatBitness, Uncertain},
    ty::{Ty, TypeCtor},
    AssocItem, Crate, Function, Module, Mutability, Name, Trait,
 };
+use super::{autoderef, lower, Canonical, InEnvironment, TraitEnvironment, TraitRef};
 /// This is used as a key for indexing impls.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum TyFingerprint {
@@ -140,14 +141,12 @@ fn def_crates(db: &impl HirDatabase, cur_crate: Crate, ty: &Ty) -> Option<ArrayV
            TypeCtor::Adt(def_id) => Some(std::iter::once(def_id.krate(db)?).collect()),
            TypeCtor::Bool => lang_item_crate!(db, cur_crate, "bool"),
            TypeCtor::Char => lang_item_crate!(db, cur_crate, "char"),
-            TypeCtor::Float(UncertainFloatTy::Known(f)) => match f.bitness {
+            TypeCtor::Float(Uncertain::Known(f)) => match f.bitness {
                // There are two lang items: one in libcore (fXX) and one in libstd (fXX_runtime)
                FloatBitness::X32 => lang_item_crate!(db, cur_crate, "f32", "f32_runtime"),
                FloatBitness::X64 => lang_item_crate!(db, cur_crate, "f64", "f64_runtime"),
            },
-            TypeCtor::Int(UncertainIntTy::Known(i)) => {
+            TypeCtor::Int(Uncertain::Known(i)) => lang_item_crate!(db, cur_crate, i.ty_to_string()),
-                lang_item_crate!(db, cur_crate, i.ty_to_string())
-            }
            TypeCtor::Str => lang_item_crate!(db, cur_crate, "str_alloc", "str"),
            TypeCtor::Slice => lang_item_crate!(db, cur_crate, "slice_alloc", "slice"),
            TypeCtor::RawPtr(Mutability::Shared) => lang_item_crate!(db, cur_crate, "const_ptr"),
diff --git a/crates/ra_hir/src/ty/primitive.rs b/crates/ra_hir/src/ty/primitive.rs
index 1749752f1..47789db87 100644
--- a/crates/ra_hir/src/ty/primitive.rs
+++ b/crates/ra_hir/src/ty/primitive.rs
@@ -4,44 +4,38 @@ use std::fmt;
 pub use hir_def::builtin_type::{FloatBitness, IntBitness, Signedness};
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+#[derive(Clone, Copy, Eq, PartialEq, Hash, Debug)]
-pub enum UncertainIntTy {
+pub enum Uncertain<T> {
    Unknown,
-    Known(IntTy),
+    Known(T),
 }
-impl From<IntTy> for UncertainIntTy {
+impl From<IntTy> for Uncertain<IntTy> {
    fn from(ty: IntTy) -> Self {
-        UncertainIntTy::Known(ty)
+        Uncertain::Known(ty)
    }
 }
-impl fmt::Display for UncertainIntTy {
+impl fmt::Display for Uncertain<IntTy> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
-            UncertainIntTy::Unknown => write!(f, "{{integer}}"),
+            Uncertain::Unknown => write!(f, "{{integer}}"),
-            UncertainIntTy::Known(ty) => write!(f, "{}", ty),
+            Uncertain::Known(ty) => write!(f, "{}", ty),
        }
    }
 }
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+impl From<FloatTy> for Uncertain<FloatTy> {
-pub enum UncertainFloatTy {
-    Unknown,
-    Known(FloatTy),
-}
-impl From<FloatTy> for UncertainFloatTy {
    fn from(ty: FloatTy) -> Self {
-        UncertainFloatTy::Known(ty)
+        Uncertain::Known(ty)
    }
 }
-impl fmt::Display for UncertainFloatTy {
+impl fmt::Display for Uncertain<FloatTy> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
-            UncertainFloatTy::Unknown => write!(f, "{{float}}"),
+            Uncertain::Unknown => write!(f, "{{float}}"),
-            UncertainFloatTy::Known(ty) => write!(f, "{}", ty),
+            Uncertain::Known(ty) => write!(f, "{}", ty),
        }
    }
 }
@@ -129,24 +123,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 +157,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,
-        }
-    }
 }
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index e56b9356e..8863c3608 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -222,7 +222,6 @@ mod collections {
 #[test]
 fn infer_while_let() {
-    covers!(infer_while_let);
    let (db, pos) = TestDB::with_position(
        r#"
 //- /main.rs
@@ -4810,3 +4809,22 @@ fn no_such_field_diagnostics() {
    "###
    );
 }
+#[test]
+fn infer_builtin_macros_line() {
+    assert_snapshot!(
+        infer(r#"
+#[rustc_builtin_macro]
+macro_rules! line {() => {}}
+fn main() {
+    let x = line!();
+}
+"#),
+        @r###"
+        ![0; 1) '6': i32
+        [64; 88) '{     ...!(); }': ()
+        [74; 75) 'x': i32
+    "###
+    );
+}
diff --git a/crates/ra_hir/src/ty/traits/chalk.rs b/crates/ra_hir/src/ty/traits/chalk.rs
index c694952f3..75351c17d 100644
--- a/crates/ra_hir/src/ty/traits/chalk.rs
+++ b/crates/ra_hir/src/ty/traits/chalk.rs
@@ -16,13 +16,13 @@ use ra_db::salsa::{InternId, InternKey};
 use super::{Canonical, ChalkContext, Impl, Obligation};
 use crate::{
    db::HirDatabase,
-    generics::GenericDef,
+    generics::{GenericDef, HasGenericParams},
    ty::display::HirDisplay,
    ty::{
        ApplicationTy, GenericPredicate, Namespace, ProjectionTy, Substs, TraitRef, Ty, TypeCtor,
        TypeWalk,
    },
-    AssocItem, Crate, HasGenericParams, ImplBlock, Trait, TypeAlias,
+    AssocItem, Crate, HasBody, ImplBlock, Trait, TypeAlias,
 };
 /// This represents a trait whose name we could not resolve.
@@ -714,7 +714,7 @@ fn closure_fn_trait_impl_datum(
    let fn_once_trait = get_fn_trait(db, krate, super::FnTrait::FnOnce)?;
    let trait_ = get_fn_trait(db, krate, data.fn_trait)?; // get corresponding fn trait
-    let num_args: u16 = match &db.body_hir(data.def)[data.expr] {
+    let num_args: u16 = match &data.def.body(db)[data.expr] {
        crate::expr::Expr::Lambda { args, .. } => args.len() as u16,
        _ => {
            log::warn!("closure for closure type {:?} not found", data);