1 files changed, 237 insertions, 190 deletions

diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index fa46ddfe9..85d4dc05c 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -14,7 +14,7 @@
 //! rustc.
 
 mod autoderef;
-mod primitive;
+pub(crate) mod primitive;
 #[cfg(test)]
 mod tests;
 pub(crate) mod method_resolution;
@@ -30,25 +30,15 @@ use ra_arena::map::ArenaMap;
 use join_to_string::join;
 use rustc_hash::FxHashMap;
 
-use ra_db::Cancelable;
-
 use crate::{
     Def, DefId, Module, Function, Struct, Enum, EnumVariant, Path, Name, ImplBlock,
     FnSignature, FnScopes,
     db::HirDatabase,
     type_ref::{TypeRef, Mutability},
     name::KnownName,
-    expr::{Body, Expr, ExprId, PatId, UnaryOp, BinaryOp, Statement},
+    expr::{Body, Expr, Literal, ExprId, PatId, UnaryOp, BinaryOp, Statement},
 };
 
-fn transpose<T>(x: Cancelable<Option<T>>) -> Option<Cancelable<T>> {
-    match x {
-        Ok(Some(t)) => Some(Ok(t)),
-        Ok(None) => None,
-        Err(e) => Some(Err(e)),
-    }
-}
-
 /// The ID of a type variable.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
 pub struct TypeVarId(u32);
@@ -107,13 +97,35 @@ impl UnifyValue for TypeVarValue {
     }
 }
 
-/// The kinds of placeholders we need during type inference. Currently, we only
-/// have type variables; in the future, we will probably also need int and float
-/// variables, for inference of literal values (e.g. `100` could be one of
+/// The kinds of placeholders we need during type inference. There's separate
+/// values for general types, and for integer and float variables. The latter
+/// two are used for inference of literal values (e.g. `100` could be one of
 /// several integer types).
-#[derive(Clone, PartialEq, Eq, Hash, Debug)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
 pub enum InferTy {
     TypeVar(TypeVarId),
+    IntVar(TypeVarId),
+    FloatVar(TypeVarId),
+}
+
+impl InferTy {
+    fn to_inner(self) -> TypeVarId {
+        match self {
+            InferTy::TypeVar(ty) | InferTy::IntVar(ty) | InferTy::FloatVar(ty) => ty,
+        }
+    }
+
+    fn fallback_value(self) -> Ty {
+        match self {
+            InferTy::TypeVar(..) => Ty::Unknown,
+            InferTy::IntVar(..) => {
+                Ty::Int(primitive::UncertainIntTy::Signed(primitive::IntTy::I32))
+            }
+            InferTy::FloatVar(..) => {
+                Ty::Float(primitive::UncertainFloatTy::Known(primitive::FloatTy::F64))
+            }
+        }
+    }
 }
 
 /// When inferring an expression, we propagate downward whatever type hint we
@@ -151,14 +163,11 @@ pub enum Ty {
     /// (a non-surrogate code point). Written as `char`.
     Char,
 
-    /// A primitive signed integer type. For example, `i32`.
-    Int(primitive::IntTy),
-
-    /// A primitive unsigned integer type. For example, `u32`.
-    Uint(primitive::UintTy),
+    /// A primitive integer type. For example, `i32`.
+    Int(primitive::UncertainIntTy),
 
     /// A primitive floating-point type. For example, `f64`.
-    Float(primitive::FloatTy),
+    Float(primitive::UncertainFloatTy),
 
     /// Structures, enumerations and unions.
     Adt {
@@ -198,8 +207,9 @@ pub enum Ty {
     // above function pointer type. Once we implement generics, we will probably
     // need this as well.
 
-    // A trait, defined with `dyn trait`.
+    // A trait, defined with `dyn Trait`.
     // Dynamic(),
+
     // The anonymous type of a closure. Used to represent the type of
     // `|a| a`.
     // Closure(DefId, ClosureSubsts<'tcx>),
@@ -251,28 +261,28 @@ impl Ty {
         module: &Module,
         impl_block: Option<&ImplBlock>,
         type_ref: &TypeRef,
-    ) -> Cancelable<Self> {
-        Ok(match type_ref {
+    ) -> Self {
+        match type_ref {
             TypeRef::Never => Ty::Never,
             TypeRef::Tuple(inner) => {
                 let inner_tys = inner
                     .iter()
                     .map(|tr| Ty::from_hir(db, module, impl_block, tr))
-                    .collect::<Cancelable<Vec<_>>>()?;
+                    .collect::<Vec<_>>();
                 Ty::Tuple(inner_tys.into())
             }
-            TypeRef::Path(path) => Ty::from_hir_path(db, module, impl_block, path)?,
+            TypeRef::Path(path) => Ty::from_hir_path(db, module, impl_block, path),
             TypeRef::RawPtr(inner, mutability) => {
-                let inner_ty = Ty::from_hir(db, module, impl_block, inner)?;
+                let inner_ty = Ty::from_hir(db, module, impl_block, inner);
                 Ty::RawPtr(Arc::new(inner_ty), *mutability)
             }
             TypeRef::Array(_inner) => Ty::Unknown, // TODO
             TypeRef::Slice(inner) => {
-                let inner_ty = Ty::from_hir(db, module, impl_block, inner)?;
+                let inner_ty = Ty::from_hir(db, module, impl_block, inner);
                 Ty::Slice(Arc::new(inner_ty))
             }
             TypeRef::Reference(inner, mutability) => {
-                let inner_ty = Ty::from_hir(db, module, impl_block, inner)?;
+                let inner_ty = Ty::from_hir(db, module, impl_block, inner);
                 Ty::Ref(Arc::new(inner_ty), *mutability)
             }
             TypeRef::Placeholder => Ty::Unknown,
@@ -280,7 +290,7 @@ impl Ty {
                 let mut inner_tys = params
                     .iter()
                     .map(|tr| Ty::from_hir(db, module, impl_block, tr))
-                    .collect::<Cancelable<Vec<_>>>()?;
+                    .collect::<Vec<_>>();
                 let return_ty = inner_tys
                     .pop()
                     .expect("TypeRef::Fn should always have at least return type");
@@ -291,7 +301,7 @@ impl Ty {
                 Ty::FnPtr(Arc::new(sig))
             }
             TypeRef::Error => Ty::Unknown,
-        })
+        }
     }
 
     pub(crate) fn from_hir_opt(
@@ -299,10 +309,8 @@ impl Ty {
         module: &Module,
         impl_block: Option<&ImplBlock>,
         type_ref: Option<&TypeRef>,
-    ) -> Cancelable<Self> {
-        type_ref
-            .map(|t| Ty::from_hir(db, module, impl_block, t))
-            .unwrap_or(Ok(Ty::Unknown))
+    ) -> Self {
+        type_ref.map_or(Ty::Unknown, |t| Ty::from_hir(db, module, impl_block, t))
     }
 
     pub(crate) fn from_hir_path(
@@ -310,33 +318,31 @@ impl Ty {
         module: &Module,
         impl_block: Option<&ImplBlock>,
         path: &Path,
-    ) -> Cancelable<Self> {
+    ) -> Self {
         if let Some(name) = path.as_ident() {
-            if let Some(KnownName::Bool) = name.as_known_name() {
-                return Ok(Ty::Bool);
-            } else if let Some(KnownName::Char) = name.as_known_name() {
-                return Ok(Ty::Char);
-            } else if let Some(KnownName::Str) = name.as_known_name() {
-                return Ok(Ty::Str);
-            } else if let Some(int_ty) = primitive::IntTy::from_name(name) {
-                return Ok(Ty::Int(int_ty));
-            } else if let Some(uint_ty) = primitive::UintTy::from_name(name) {
-                return Ok(Ty::Uint(uint_ty));
-            } else if let Some(float_ty) = primitive::FloatTy::from_name(name) {
-                return Ok(Ty::Float(float_ty));
+            if let Some(int_ty) = primitive::UncertainIntTy::from_name(name) {
+                return Ty::Int(int_ty);
+            } else if let Some(float_ty) = primitive::UncertainFloatTy::from_name(name) {
+                return Ty::Float(float_ty);
             } else if name.as_known_name() == Some(KnownName::SelfType) {
                 return Ty::from_hir_opt(db, module, None, impl_block.map(|i| i.target_type()));
+            } else if let Some(known) = name.as_known_name() {
+                match known {
+                    KnownName::Bool => return Ty::Bool,
+                    KnownName::Char => return Ty::Char,
+                    KnownName::Str => return Ty::Str,
+                    _ => {}
+                }
             }
         }
 
         // Resolve in module (in type namespace)
-        let resolved = if let Some(r) = module.resolve_path(db, path)?.take_types() {
+        let resolved = if let Some(r) = module.resolve_path(db, path).take_types() {
             r
         } else {
-            return Ok(Ty::Unknown);
+            return Ty::Unknown;
         };
-        let ty = db.type_for_def(resolved)?;
-        Ok(ty)
+        db.type_for_def(resolved)
     }
 
     pub fn unit() -> Self {
@@ -392,7 +398,6 @@ impl fmt::Display for Ty {
             Ty::Bool => write!(f, "bool"),
             Ty::Char => write!(f, "char"),
             Ty::Int(t) => write!(f, "{}", t.ty_to_string()),
-            Ty::Uint(t) => write!(f, "{}", t.ty_to_string()),
             Ty::Float(t) => write!(f, "{}", t.ty_to_string()),
             Ty::Str => write!(f, "str"),
             Ty::Slice(t) => write!(f, "[{}]", t),
@@ -427,47 +432,47 @@ impl fmt::Display for Ty {
 
 /// Compute the declared type of a function. This should not need to look at the
 /// function body.
-fn type_for_fn(db: &impl HirDatabase, f: Function) -> Cancelable<Ty> {
+fn type_for_fn(db: &impl HirDatabase, f: Function) -> Ty {
     let signature = f.signature(db);
-    let module = f.module(db)?;
-    let impl_block = f.impl_block(db)?;
+    let module = f.module(db);
+    let impl_block = f.impl_block(db);
     // TODO we ignore type parameters for now
     let input = signature
         .params()
         .iter()
         .map(|tr| Ty::from_hir(db, &module, impl_block.as_ref(), tr))
-        .collect::<Cancelable<Vec<_>>>()?;
-    let output = Ty::from_hir(db, &module, impl_block.as_ref(), signature.ret_type())?;
+        .collect::<Vec<_>>();
+    let output = Ty::from_hir(db, &module, impl_block.as_ref(), signature.ret_type());
     let sig = FnSig { input, output };
-    Ok(Ty::FnPtr(Arc::new(sig)))
+    Ty::FnPtr(Arc::new(sig))
 }
 
-fn type_for_struct(db: &impl HirDatabase, s: Struct) -> Cancelable<Ty> {
-    Ok(Ty::Adt {
+fn type_for_struct(db: &impl HirDatabase, s: Struct) -> Ty {
+    Ty::Adt {
         def_id: s.def_id(),
-        name: s.name(db)?.unwrap_or_else(Name::missing),
-    })
+        name: s.name(db).unwrap_or_else(Name::missing),
+    }
 }
 
-pub(crate) fn type_for_enum(db: &impl HirDatabase, s: Enum) -> Cancelable<Ty> {
-    Ok(Ty::Adt {
+pub(crate) fn type_for_enum(db: &impl HirDatabase, s: Enum) -> Ty {
+    Ty::Adt {
         def_id: s.def_id(),
-        name: s.name(db)?.unwrap_or_else(Name::missing),
-    })
+        name: s.name(db).unwrap_or_else(Name::missing),
+    }
 }
 
-pub(crate) fn type_for_enum_variant(db: &impl HirDatabase, ev: EnumVariant) -> Cancelable<Ty> {
-    let enum_parent = ev.parent_enum(db)?;
+pub(crate) fn type_for_enum_variant(db: &impl HirDatabase, ev: EnumVariant) -> Ty {
+    let enum_parent = ev.parent_enum(db);
 
     type_for_enum(db, enum_parent)
 }
 
-pub(super) fn type_for_def(db: &impl HirDatabase, def_id: DefId) -> Cancelable<Ty> {
-    let def = def_id.resolve(db)?;
+pub(super) fn type_for_def(db: &impl HirDatabase, def_id: DefId) -> Ty {
+    let def = def_id.resolve(db);
     match def {
         Def::Module(..) => {
             log::debug!("trying to get type for module {:?}", def_id);
-            Ok(Ty::Unknown)
+            Ty::Unknown
         }
         Def::Function(f) => type_for_fn(db, f),
         Def::Struct(s) => type_for_struct(db, s),
@@ -479,35 +484,26 @@ pub(super) fn type_for_def(db: &impl HirDatabase, def_id: DefId) -> Cancelable<T
                 def_id,
                 def
             );
-            Ok(Ty::Unknown)
+            Ty::Unknown
         }
     }
 }
 
-pub(super) fn type_for_field(
-    db: &impl HirDatabase,
-    def_id: DefId,
-    field: Name,
-) -> Cancelable<Option<Ty>> {
-    let def = def_id.resolve(db)?;
+pub(super) fn type_for_field(db: &impl HirDatabase, def_id: DefId, field: Name) -> Option<Ty> {
+    let def = def_id.resolve(db);
     let variant_data = match def {
-        Def::Struct(s) => s.variant_data(db)?,
-        Def::EnumVariant(ev) => ev.variant_data(db)?,
+        Def::Struct(s) => s.variant_data(db),
+        Def::EnumVariant(ev) => ev.variant_data(db),
         // TODO: unions
         _ => panic!(
             "trying to get type for field in non-struct/variant {:?}",
             def_id
         ),
     };
-    let module = def_id.module(db)?;
-    let impl_block = def_id.impl_block(db)?;
-    let type_ref = ctry!(variant_data.get_field_type_ref(&field));
-    Ok(Some(Ty::from_hir(
-        db,
-        &module,
-        impl_block.as_ref(),
-        &type_ref,
-    )?))
+    let module = def_id.module(db);
+    let impl_block = def_id.impl_block(db);
+    let type_ref = variant_data.get_field_type_ref(&field)?;
+    Some(Ty::from_hir(db, &module, impl_block.as_ref(), &type_ref))
 }
 
 /// The result of type inference: A mapping from expressions and patterns to types.
@@ -587,7 +583,7 @@ fn binary_op_return_ty(op: BinaryOp, rhs_ty: Ty) -> Ty {
         | BinaryOp::BitwiseAnd
         | BinaryOp::BitwiseOr
         | BinaryOp::BitwiseXor => match rhs_ty {
-            Ty::Uint(..) | Ty::Int(..) | Ty::Float(..) => rhs_ty,
+            Ty::Int(..) | Ty::Float(..) => rhs_ty,
             _ => Ty::Unknown,
         },
         BinaryOp::RangeRightOpen | BinaryOp::RangeRightClosed => Ty::Unknown,
@@ -598,7 +594,7 @@ fn binary_op_rhs_expectation(op: BinaryOp, lhs_ty: Ty) -> Ty {
     match op {
         BinaryOp::BooleanAnd | BinaryOp::BooleanOr => Ty::Bool,
         BinaryOp::Assignment | BinaryOp::EqualityTest => match lhs_ty {
-            Ty::Uint(..) | Ty::Int(..) | Ty::Float(..) | Ty::Str | Ty::Char | Ty::Bool => lhs_ty,
+            Ty::Int(..) | Ty::Float(..) | Ty::Str | Ty::Char | Ty::Bool => lhs_ty,
             _ => Ty::Unknown,
         },
         BinaryOp::LesserEqualTest
@@ -625,7 +621,7 @@ fn binary_op_rhs_expectation(op: BinaryOp, lhs_ty: Ty) -> Ty {
         | BinaryOp::BitwiseAnd
         | BinaryOp::BitwiseOr
         | BinaryOp::BitwiseXor => match lhs_ty {
-            Ty::Uint(..) | Ty::Int(..) | Ty::Float(..) => lhs_ty,
+            Ty::Int(..) | Ty::Float(..) => lhs_ty,
             _ => Ty::Unknown,
         },
         _ => Ty::Unknown,
@@ -684,7 +680,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         self.type_of_pat.insert(pat, ty);
     }
 
-    fn make_ty(&self, type_ref: &TypeRef) -> Cancelable<Ty> {
+    fn make_ty(&self, type_ref: &TypeRef) -> Ty {
         Ty::from_hir(self.db, &self.module, self.impl_block.as_ref(), type_ref)
     }
 
@@ -695,13 +691,17 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         match (&*ty1, &*ty2) {
             (Ty::Unknown, ..) => true,
             (.., Ty::Unknown) => true,
-            (Ty::Bool, _)
-            | (Ty::Str, _)
-            | (Ty::Never, _)
-            | (Ty::Char, _)
-            | (Ty::Int(..), Ty::Int(..))
-            | (Ty::Uint(..), Ty::Uint(..))
-            | (Ty::Float(..), Ty::Float(..)) => ty1 == ty2,
+            (Ty::Int(t1), Ty::Int(t2)) => match (t1, t2) {
+                (primitive::UncertainIntTy::Unknown, _)
+                | (_, primitive::UncertainIntTy::Unknown) => true,
+                _ => t1 == t2,
+            },
+            (Ty::Float(t1), Ty::Float(t2)) => match (t1, t2) {
+                (primitive::UncertainFloatTy::Unknown, _)
+                | (_, primitive::UncertainFloatTy::Unknown) => true,
+                _ => t1 == t2,
+            },
+            (Ty::Bool, _) | (Ty::Str, _) | (Ty::Never, _) | (Ty::Char, _) => ty1 == ty2,
             (
                 Ty::Adt {
                     def_id: def_id1, ..
@@ -718,12 +718,19 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 .iter()
                 .zip(ts2.iter())
                 .all(|(t1, t2)| self.unify(t1, t2)),
-            (Ty::Infer(InferTy::TypeVar(tv1)), Ty::Infer(InferTy::TypeVar(tv2))) => {
+            (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))) => {
                 // both type vars are unknown since we tried to resolve them
                 self.var_unification_table.union(*tv1, *tv2);
                 true
             }
-            (Ty::Infer(InferTy::TypeVar(tv)), other) | (other, Ty::Infer(InferTy::TypeVar(tv))) => {
+            (Ty::Infer(InferTy::TypeVar(tv)), other)
+            | (other, Ty::Infer(InferTy::TypeVar(tv)))
+            | (Ty::Infer(InferTy::IntVar(tv)), other)
+            | (other, Ty::Infer(InferTy::IntVar(tv)))
+            | (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()));
@@ -739,10 +746,24 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         ))
     }
 
+    fn new_integer_var(&mut self) -> Ty {
+        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),
+        ))
+    }
+
     /// Replaces Ty::Unknown by a new type var, so we can maybe still infer it.
     fn insert_type_vars_shallow(&mut self, ty: Ty) -> Ty {
         match ty {
             Ty::Unknown => self.new_type_var(),
+            Ty::Int(primitive::UncertainIntTy::Unknown) => self.new_integer_var(),
+            Ty::Float(primitive::UncertainFloatTy::Unknown) => self.new_float_var(),
             _ => ty,
         }
     }
@@ -757,12 +778,13 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
     /// known type.
     fn resolve_ty_as_possible(&mut self, ty: Ty) -> Ty {
         ty.fold(&mut |ty| match ty {
-            Ty::Infer(InferTy::TypeVar(tv)) => {
-                if let Some(known_ty) = self.var_unification_table.probe_value(tv).known() {
+            Ty::Infer(tv) => {
+                let inner = tv.to_inner();
+                if let Some(known_ty) = self.var_unification_table.probe_value(inner).known() {
                     // known_ty may contain other variables that are known by now
                     self.resolve_ty_as_possible(known_ty.clone())
                 } else {
-                    Ty::Infer(InferTy::TypeVar(tv))
+                    ty
                 }
             }
             _ => ty,
@@ -773,8 +795,9 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
     /// otherwise, return ty.
     fn resolve_ty_shallow<'b>(&mut self, ty: &'b Ty) -> Cow<'b, Ty> {
         match ty {
-            Ty::Infer(InferTy::TypeVar(tv)) => {
-                match self.var_unification_table.probe_value(*tv).known() {
+            Ty::Infer(tv) => {
+                let inner = tv.to_inner();
+                match self.var_unification_table.probe_value(inner).known() {
                     Some(known_ty) => {
                         // The known_ty can't be a type var itself
                         Cow::Owned(known_ty.clone())
@@ -790,61 +813,62 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
     /// replaced by Ty::Unknown.
     fn resolve_ty_completely(&mut self, ty: Ty) -> Ty {
         ty.fold(&mut |ty| match ty {
-            Ty::Infer(InferTy::TypeVar(tv)) => {
-                if let Some(known_ty) = self.var_unification_table.probe_value(tv).known() {
+            Ty::Infer(tv) => {
+                let inner = tv.to_inner();
+                if let Some(known_ty) = self.var_unification_table.probe_value(inner).known() {
                     // known_ty may contain other variables that are known by now
                     self.resolve_ty_completely(known_ty.clone())
                 } else {
-                    Ty::Unknown
+                    tv.fallback_value()
                 }
             }
             _ => ty,
         })
     }
 
-    fn infer_path_expr(&mut self, expr: ExprId, path: &Path) -> Cancelable<Option<Ty>> {
+    fn infer_path_expr(&mut self, expr: ExprId, path: &Path) -> Option<Ty> {
         if path.is_ident() || path.is_self() {
             // resolve locally
             let name = path.as_ident().cloned().unwrap_or_else(Name::self_param);
             if let Some(scope_entry) = self.scopes.resolve_local_name(expr, name) {
-                let ty = ctry!(self.type_of_pat.get(scope_entry.pat()));
+                let ty = self.type_of_pat.get(scope_entry.pat())?;
                 let ty = self.resolve_ty_as_possible(ty.clone());
-                return Ok(Some(ty));
+                return Some(ty);
             };
         };
 
         // resolve in module
-        let resolved = ctry!(self.module.resolve_path(self.db, &path)?.take_values());
-        let ty = self.db.type_for_def(resolved)?;
+        let resolved = self.module.resolve_path(self.db, &path).take_values()?;
+        let ty = self.db.type_for_def(resolved);
         let ty = self.insert_type_vars(ty);
-        Ok(Some(ty))
+        Some(ty)
     }
 
-    fn resolve_variant(&self, path: Option<&Path>) -> Cancelable<(Ty, Option<DefId>)> {
+    fn resolve_variant(&self, path: Option<&Path>) -> (Ty, Option<DefId>) {
         let path = if let Some(path) = path {
             path
         } else {
-            return Ok((Ty::Unknown, None));
+            return (Ty::Unknown, None);
         };
-        let def_id = if let Some(def_id) = self.module.resolve_path(self.db, &path)?.take_types() {
+        let def_id = if let Some(def_id) = self.module.resolve_path(self.db, &path).take_types() {
             def_id
         } else {
-            return Ok((Ty::Unknown, None));
+            return (Ty::Unknown, None);
         };
-        Ok(match def_id.resolve(self.db)? {
+        match def_id.resolve(self.db) {
             Def::Struct(s) => {
-                let ty = type_for_struct(self.db, s)?;
+                let ty = type_for_struct(self.db, s);
                 (ty, Some(def_id))
             }
             Def::EnumVariant(ev) => {
-                let ty = type_for_enum_variant(self.db, ev)?;
+                let ty = type_for_enum_variant(self.db, ev);
                 (ty, Some(def_id))
             }
             _ => (Ty::Unknown, None),
-        })
+        }
     }
 
-    fn infer_expr(&mut self, expr: ExprId, expected: &Expectation) -> Cancelable<Ty> {
+    fn infer_expr(&mut self, expr: ExprId, expected: &Expectation) -> Ty {
         let body = Arc::clone(&self.body); // avoid borrow checker problem
         let ty = match &body[expr] {
             Expr::Missing => Ty::Unknown,
@@ -854,11 +878,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 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)?;
+                self.infer_expr(*condition, &Expectation::has_type(Ty::Bool));
+                let then_ty = self.infer_expr(*then_branch, expected);
                 match else_branch {
                     Some(else_branch) => {
-                        self.infer_expr(*else_branch, expected)?;
+                        self.infer_expr(*else_branch, expected);
                     }
                     None => {
                         // no else branch -> unit
@@ -867,31 +891,31 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 };
                 then_ty
             }
-            Expr::Block { statements, tail } => self.infer_block(statements, *tail, expected)?,
+            Expr::Block { statements, tail } => self.infer_block(statements, *tail, expected),
             Expr::Loop { body } => {
-                self.infer_expr(*body, &Expectation::has_type(Ty::unit()))?;
+                self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
                 // TODO handle break with value
                 Ty::Never
             }
             Expr::While { condition, body } => {
                 // while let is desugared to a match loop, so this is always simple while
-                self.infer_expr(*condition, &Expectation::has_type(Ty::Bool))?;
-                self.infer_expr(*body, &Expectation::has_type(Ty::unit()))?;
+                self.infer_expr(*condition, &Expectation::has_type(Ty::Bool));
+                self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
                 Ty::unit()
             }
             Expr::For { iterable, body, .. } => {
                 let _iterable_ty = self.infer_expr(*iterable, &Expectation::none());
                 // TODO write type for pat
-                self.infer_expr(*body, &Expectation::has_type(Ty::unit()))?;
+                self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
                 Ty::unit()
             }
             Expr::Lambda { body, .. } => {
                 // TODO write types for args, infer lambda type etc.
-                let _body_ty = self.infer_expr(*body, &Expectation::none())?;
+                let _body_ty = self.infer_expr(*body, &Expectation::none());
                 Ty::Unknown
             }
             Expr::Call { callee, args } => {
-                let callee_ty = self.infer_expr(*callee, &Expectation::none())?;
+                let callee_ty = self.infer_expr(*callee, &Expectation::none());
                 let (param_tys, ret_ty) = match &callee_ty {
                     Ty::FnPtr(sig) => (&sig.input[..], sig.output.clone()),
                     _ => {
@@ -904,7 +928,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                     self.infer_expr(
                         *arg,
                         &Expectation::has_type(param_tys.get(i).cloned().unwrap_or(Ty::Unknown)),
-                    )?;
+                    );
                 }
                 ret_ty
             }
@@ -913,12 +937,12 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 args,
                 method_name,
             } => {
-                let receiver_ty = self.infer_expr(*receiver, &Expectation::none())?;
-                let resolved = receiver_ty.clone().lookup_method(self.db, 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 {
                     Some(def_id) => {
                         self.write_method_resolution(expr, def_id);
-                        self.db.type_for_def(def_id)?
+                        self.db.type_for_def(def_id)
                     }
                     None => Ty::Unknown,
                 };
@@ -940,32 +964,32 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                     self.infer_expr(
                         *arg,
                         &Expectation::has_type(param_tys.get(i).cloned().unwrap_or(Ty::Unknown)),
-                    )?;
+                    );
                 }
                 ret_ty
             }
             Expr::Match { expr, arms } => {
-                let _ty = self.infer_expr(*expr, &Expectation::none())?;
+                let _ty = self.infer_expr(*expr, &Expectation::none());
                 for arm in arms {
                     // TODO type the bindings in pats
                     // TODO type the guard
-                    let _ty = self.infer_expr(arm.expr, &Expectation::none())?;
+                    let _ty = self.infer_expr(arm.expr, &Expectation::none());
                 }
                 // TODO unify all the match arm types
                 Ty::Unknown
             }
-            Expr::Path(p) => self.infer_path_expr(expr, p)?.unwrap_or(Ty::Unknown),
+            Expr::Path(p) => self.infer_path_expr(expr, p).unwrap_or(Ty::Unknown),
             Expr::Continue => Ty::Never,
             Expr::Break { expr } => {
                 if let Some(expr) = expr {
                     // TODO handle break with value
-                    self.infer_expr(*expr, &Expectation::none())?;
+                    self.infer_expr(*expr, &Expectation::none());
                 }
                 Ty::Never
             }
             Expr::Return { expr } => {
                 if let Some(expr) = expr {
-                    self.infer_expr(*expr, &Expectation::has_type(self.return_ty.clone()))?;
+                    self.infer_expr(*expr, &Expectation::has_type(self.return_ty.clone()));
                 }
                 Ty::Never
             }
@@ -974,62 +998,60 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 fields,
                 spread,
             } => {
-                let (ty, def_id) = self.resolve_variant(path.as_ref())?;
+                let (ty, def_id) = self.resolve_variant(path.as_ref());
                 for field in fields {
                     let field_ty = if let Some(def_id) = def_id {
                         self.db
-                            .type_for_field(def_id, field.name.clone())?
+                            .type_for_field(def_id, field.name.clone())
                             .unwrap_or(Ty::Unknown)
                     } else {
                         Ty::Unknown
                     };
-                    self.infer_expr(field.expr, &Expectation::has_type(field_ty))?;
+                    self.infer_expr(field.expr, &Expectation::has_type(field_ty));
                 }
                 if let Some(expr) = spread {
-                    self.infer_expr(*expr, &Expectation::has_type(ty.clone()))?;
+                    self.infer_expr(*expr, &Expectation::has_type(ty.clone()));
                 }
                 ty
             }
             Expr::Field { expr, name } => {
-                let receiver_ty = self.infer_expr(*expr, &Expectation::none())?;
+                let receiver_ty = self.infer_expr(*expr, &Expectation::none());
                 let ty = receiver_ty
                     .autoderef(self.db)
                     .find_map(|derefed_ty| match derefed_ty {
                         // this is more complicated than necessary because type_for_field is cancelable
                         Ty::Tuple(fields) => {
                             let i = name.to_string().parse::<usize>().ok();
-                            i.and_then(|i| fields.get(i).cloned()).map(Ok)
-                        }
-                        Ty::Adt { def_id, .. } => {
-                            transpose(self.db.type_for_field(def_id, name.clone()))
+                            i.and_then(|i| fields.get(i).cloned())
                         }
+                        Ty::Adt { def_id, .. } => self.db.type_for_field(def_id, name.clone()),
                         _ => None,
                     })
-                    .unwrap_or(Ok(Ty::Unknown))?;
+                    .unwrap_or(Ty::Unknown);
                 self.insert_type_vars(ty)
             }
             Expr::Try { expr } => {
-                let _inner_ty = self.infer_expr(*expr, &Expectation::none())?;
+                let _inner_ty = self.infer_expr(*expr, &Expectation::none());
                 Ty::Unknown
             }
             Expr::Cast { expr, type_ref } => {
-                let _inner_ty = self.infer_expr(*expr, &Expectation::none())?;
+                let _inner_ty = self.infer_expr(*expr, &Expectation::none());
                 let cast_ty =
-                    Ty::from_hir(self.db, &self.module, self.impl_block.as_ref(), type_ref)?;
+                    Ty::from_hir(self.db, &self.module, self.impl_block.as_ref(), type_ref);
                 let cast_ty = self.insert_type_vars(cast_ty);
                 // TODO check the cast...
                 cast_ty
             }
             Expr::Ref { expr, mutability } => {
                 // TODO pass the expectation down
-                let inner_ty = self.infer_expr(*expr, &Expectation::none())?;
+                let inner_ty = self.infer_expr(*expr, &Expectation::none());
                 // TODO reference coercions etc.
                 Ty::Ref(Arc::new(inner_ty), *mutability)
             }
             Expr::UnaryOp { expr, op } => {
-                let inner_ty = self.infer_expr(*expr, &Expectation::none())?;
+                let inner_ty = self.infer_expr(*expr, &Expectation::none());
                 match op {
-                    Some(UnaryOp::Deref) => {
+                    UnaryOp::Deref => {
                         if let Some(derefed_ty) = inner_ty.builtin_deref() {
                             derefed_ty
                         } else {
@@ -1037,7 +1059,20 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                             Ty::Unknown
                         }
                     }
-                    _ => Ty::Unknown,
+                    UnaryOp::Neg => {
+                        match inner_ty {
+                            Ty::Int(primitive::UncertainIntTy::Unknown)
+                            | Ty::Int(primitive::UncertainIntTy::Signed(..))
+                            | Ty::Infer(InferTy::IntVar(..))
+                            | Ty::Infer(InferTy::FloatVar(..))
+                            | Ty::Float(..) => inner_ty,
+                            // TODO: resolve ops::Neg trait
+                            _ => Ty::Unknown,
+                        }
+                    }
+                    UnaryOp::Not if inner_ty == Ty::Bool => Ty::Bool,
+                    // TODO: resolve ops::Not trait for inner_ty
+                    UnaryOp::Not => Ty::Unknown,
                 }
             }
             Expr::BinaryOp { lhs, rhs, op } => match op {
@@ -1048,11 +1083,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                         }
                         _ => Expectation::none(),
                     };
-                    let lhs_ty = self.infer_expr(*lhs, &lhs_expectation)?;
+                    let lhs_ty = self.infer_expr(*lhs, &lhs_expectation);
                     // TODO: find implementation of trait corresponding to operation
                     // symbol and resolve associated `Output` type
                     let rhs_expectation = binary_op_rhs_expectation(*op, lhs_ty);
-                    let rhs_ty = self.infer_expr(*rhs, &Expectation::has_type(rhs_expectation))?;
+                    let rhs_ty = self.infer_expr(*rhs, &Expectation::has_type(rhs_expectation));
 
                     // TODO: similar as above, return ty is often associated trait type
                     binary_op_return_ty(*op, rhs_ty)
@@ -1062,18 +1097,32 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             Expr::Tuple { exprs } => {
                 let mut ty_vec = Vec::with_capacity(exprs.len());
                 for arg in exprs.iter() {
-                    ty_vec.push(self.infer_expr(*arg, &Expectation::none())?);
+                    ty_vec.push(self.infer_expr(*arg, &Expectation::none()));
                 }
 
                 Ty::Tuple(Arc::from(ty_vec))
             }
+            Expr::Literal(lit) => match lit {
+                Literal::Bool(..) => Ty::Bool,
+                Literal::String(..) => Ty::Ref(Arc::new(Ty::Str), Mutability::Shared),
+                Literal::ByteString(..) => {
+                    let byte_type = Arc::new(Ty::Int(primitive::UncertainIntTy::Unsigned(
+                        primitive::UintTy::U8,
+                    )));
+                    let slice_type = Arc::new(Ty::Slice(byte_type));
+                    Ty::Ref(slice_type, Mutability::Shared)
+                }
+                Literal::Char(..) => Ty::Char,
+                Literal::Int(_v, ty) => Ty::Int(*ty),
+                Literal::Float(_v, ty) => Ty::Float(*ty),
+            },
         };
         // use a new type variable if we got Ty::Unknown here
         let ty = self.insert_type_vars_shallow(ty);
         self.unify(&ty, &expected.ty);
         let ty = self.resolve_ty_as_possible(ty);
         self.write_expr_ty(expr, ty.clone());
-        Ok(ty)
+        ty
     }
 
     fn infer_block(
@@ -1081,7 +1130,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         statements: &[Statement],
         tail: Option<ExprId>,
         expected: &Expectation,
-    ) -> Cancelable<Ty> {
+    ) -> Ty {
         for stmt in statements {
             match stmt {
                 Statement::Let {
@@ -1094,10 +1143,10 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                         &self.module,
                         self.impl_block.as_ref(),
                         type_ref.as_ref(),
-                    )?;
+                    );
                     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))?;
+                        let expr_ty = self.infer_expr(*expr, &Expectation::has_type(decl_ty));
                         expr_ty
                     } else {
                         decl_ty
@@ -1106,55 +1155,53 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                     self.write_pat_ty(*pat, ty);
                 }
                 Statement::Expr(expr) => {
-                    self.infer_expr(*expr, &Expectation::none())?;
+                    self.infer_expr(*expr, &Expectation::none());
                 }
             }
         }
         let ty = if let Some(expr) = tail {
-            self.infer_expr(expr, expected)?
+            self.infer_expr(expr, expected)
         } else {
             Ty::unit()
         };
-        Ok(ty)
+        ty
     }
 
-    fn collect_fn_signature(&mut self, signature: &FnSignature) -> Cancelable<()> {
+    fn collect_fn_signature(&mut self, signature: &FnSignature) {
         let body = Arc::clone(&self.body); // avoid borrow checker problem
         for (type_ref, pat) in signature.params().iter().zip(body.params()) {
-            let ty = self.make_ty(type_ref)?;
+            let ty = self.make_ty(type_ref);
             let ty = self.insert_type_vars(ty);
             self.write_pat_ty(*pat, ty);
         }
         self.return_ty = {
-            let ty = self.make_ty(signature.ret_type())?;
+            let ty = self.make_ty(signature.ret_type());
             let ty = self.insert_type_vars(ty);
             ty
         };
-        Ok(())
     }
 
-    fn infer_body(&mut self) -> Cancelable<()> {
+    fn infer_body(&mut self) {
         self.infer_expr(
             self.body.body_expr(),
             &Expectation::has_type(self.return_ty.clone()),
-        )?;
-        Ok(())
+        );
     }
 }
 
-pub fn infer(db: &impl HirDatabase, def_id: DefId) -> Cancelable<Arc<InferenceResult>> {
-    db.check_canceled()?;
+pub fn infer(db: &impl HirDatabase, def_id: DefId) -> Arc<InferenceResult> {
+    db.check_canceled();
     let function = Function::new(def_id); // TODO: consts also need inference
-    let body = function.body(db)?;
-    let scopes = db.fn_scopes(def_id)?;
-    let module = function.module(db)?;
-    let impl_block = function.impl_block(db)?;
+    let body = function.body(db);
+    let scopes = db.fn_scopes(def_id);
+    let module = function.module(db);
+    let impl_block = function.impl_block(db);
     let mut ctx = InferenceContext::new(db, body, scopes, module, impl_block);
 
     let signature = function.signature(db);
-    ctx.collect_fn_signature(&signature)?;
+    ctx.collect_fn_signature(&signature);
 
-    ctx.infer_body()?;
+    ctx.infer_body();
 
-    Ok(Arc::new(ctx.resolve_all()))
+    Arc::new(ctx.resolve_all())
 }