27 files changed, 780 insertions, 637 deletions

diff --git a/crates/ra_hir/src/adt.rs b/crates/ra_hir/src/adt.rs
index bcb705c24..d87fe7049 100644
--- a/crates/ra_hir/src/adt.rs
+++ b/crates/ra_hir/src/adt.rs
@@ -1,6 +1,5 @@
 use std::sync::Arc;
 
-use ra_db::Cancelable;
 use ra_syntax::{
     SyntaxNode,
     ast::{self, NameOwner, StructFlavor, AstNode}
@@ -18,8 +17,8 @@ impl Struct {
         Struct { def_id }
     }
 
-    pub(crate) fn variant_data(&self, db: &impl HirDatabase) -> Cancelable<Arc<VariantData>> {
-        Ok(db.struct_data(self.def_id)?.variant_data.clone())
+    pub(crate) fn variant_data(&self, db: &impl HirDatabase) -> Arc<VariantData> {
+        db.struct_data(self.def_id).variant_data.clone()
     }
 }
 
@@ -37,16 +36,13 @@ impl StructData {
         StructData { name, variant_data }
     }
 
-    pub(crate) fn struct_data_query(
-        db: &impl HirDatabase,
-        def_id: DefId,
-    ) -> Cancelable<Arc<StructData>> {
+    pub(crate) fn struct_data_query(db: &impl HirDatabase, def_id: DefId) -> Arc<StructData> {
         let def_loc = def_id.loc(db);
         assert!(def_loc.kind == DefKind::Struct);
         let syntax = db.file_item(def_loc.source_item_id);
         let struct_def =
             ast::StructDef::cast(&syntax).expect("struct def should point to StructDef node");
-        Ok(Arc::new(StructData::new(struct_def)))
+        Arc::new(StructData::new(struct_def))
     }
 }
 
@@ -84,10 +80,7 @@ impl EnumData {
         EnumData { name, variants }
     }
 
-    pub(crate) fn enum_data_query(
-        db: &impl HirDatabase,
-        def_id: DefId,
-    ) -> Cancelable<Arc<EnumData>> {
+    pub(crate) fn enum_data_query(db: &impl HirDatabase, def_id: DefId) -> Arc<EnumData> {
         let def_loc = def_id.loc(db);
         assert!(def_loc.kind == DefKind::Enum);
         let syntax = db.file_item(def_loc.source_item_id);
@@ -107,7 +100,7 @@ impl EnumData {
         } else {
             Vec::new()
         };
-        Ok(Arc::new(EnumData::new(enum_def, variants)))
+        Arc::new(EnumData::new(enum_def, variants))
     }
 }
 
@@ -133,7 +126,7 @@ impl EnumVariantData {
     pub(crate) fn enum_variant_data_query(
         db: &impl HirDatabase,
         def_id: DefId,
-    ) -> Cancelable<Arc<EnumVariantData>> {
+    ) -> Arc<EnumVariantData> {
         let def_loc = def_id.loc(db);
         assert!(def_loc.kind == DefKind::EnumVariant);
         let syntax = db.file_item(def_loc.source_item_id);
@@ -146,10 +139,7 @@ impl EnumVariantData {
             .expect("enum variant list should have enum ancestor");
         let enum_def_id = get_def_id(db, &def_loc, enum_node, DefKind::Enum);
 
-        Ok(Arc::new(EnumVariantData::new(
-            variant_def,
-            Enum::new(enum_def_id),
-        )))
+        Arc::new(EnumVariantData::new(variant_def, Enum::new(enum_def_id)))
     }
 }
 
diff --git a/crates/ra_hir/src/code_model_api.rs b/crates/ra_hir/src/code_model_api.rs
index 91b235594..0cf7deac9 100644
--- a/crates/ra_hir/src/code_model_api.rs
+++ b/crates/ra_hir/src/code_model_api.rs
@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
 use relative_path::RelativePathBuf;
-use ra_db::{CrateId, Cancelable, FileId};
+use ra_db::{CrateId, FileId};
 use ra_syntax::{ast, TreeArc, SyntaxNode};
 
 use crate::{
@@ -33,10 +33,10 @@ impl Crate {
     pub fn crate_id(&self) -> CrateId {
         self.crate_id
     }
-    pub fn dependencies(&self, db: &impl HirDatabase) -> Cancelable<Vec<CrateDependency>> {
-        Ok(self.dependencies_impl(db))
+    pub fn dependencies(&self, db: &impl HirDatabase) -> Vec<CrateDependency> {
+        self.dependencies_impl(db)
     }
-    pub fn root_module(&self, db: &impl HirDatabase) -> Cancelable<Option<Module>> {
+    pub fn root_module(&self, db: &impl HirDatabase) -> Option<Module> {
         self.root_module_impl(db)
     }
 }
@@ -78,12 +78,12 @@ pub enum Problem {
 
 impl Module {
     /// Name of this module.
-    pub fn name(&self, db: &impl HirDatabase) -> Cancelable<Option<Name>> {
+    pub fn name(&self, db: &impl HirDatabase) -> Option<Name> {
         self.name_impl(db)
     }
 
     /// Returns a node which defines this module. That is, a file or a `mod foo {}` with items.
-    pub fn definition_source(&self, db: &impl HirDatabase) -> Cancelable<(FileId, ModuleSource)> {
+    pub fn definition_source(&self, db: &impl HirDatabase) -> (FileId, ModuleSource) {
         self.definition_source_impl(db)
     }
 
@@ -92,60 +92,57 @@ impl Module {
     pub fn declaration_source(
         &self,
         db: &impl HirDatabase,
-    ) -> Cancelable<Option<(FileId, TreeArc<ast::Module>)>> {
+    ) -> Option<(FileId, TreeArc<ast::Module>)> {
         self.declaration_source_impl(db)
     }
 
     /// Returns the crate this module is part of.
-    pub fn krate(&self, db: &impl HirDatabase) -> Cancelable<Option<Crate>> {
+    pub fn krate(&self, db: &impl HirDatabase) -> Option<Crate> {
         self.krate_impl(db)
     }
 
     /// Topmost parent of this module. Every module has a `crate_root`, but some
     /// might be missing `krate`. This can happen if a module's file is not included
     /// in the module tree of any target in Cargo.toml.
-    pub fn crate_root(&self, db: &impl HirDatabase) -> Cancelable<Module> {
+    pub fn crate_root(&self, db: &impl HirDatabase) -> Module {
         self.crate_root_impl(db)
     }
 
     /// Finds a child module with the specified name.
-    pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
+    pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Option<Module> {
         self.child_impl(db, name)
     }
 
     /// Iterates over all child modules.
-    pub fn children(&self, db: &impl HirDatabase) -> Cancelable<impl Iterator<Item = Module>> {
+    pub fn children(&self, db: &impl HirDatabase) -> impl Iterator<Item = Module> {
         self.children_impl(db)
     }
 
     /// Finds a parent module.
-    pub fn parent(&self, db: &impl HirDatabase) -> Cancelable<Option<Module>> {
+    pub fn parent(&self, db: &impl HirDatabase) -> Option<Module> {
         self.parent_impl(db)
     }
 
-    pub fn path_to_root(&self, db: &impl HirDatabase) -> Cancelable<Vec<Module>> {
+    pub fn path_to_root(&self, db: &impl HirDatabase) -> Vec<Module> {
         let mut res = vec![self.clone()];
         let mut curr = self.clone();
-        while let Some(next) = curr.parent(db)? {
+        while let Some(next) = curr.parent(db) {
             res.push(next.clone());
             curr = next
         }
-        Ok(res)
+        res
     }
 
     /// Returns a `ModuleScope`: a set of items, visible in this module.
-    pub fn scope(&self, db: &impl HirDatabase) -> Cancelable<ModuleScope> {
+    pub fn scope(&self, db: &impl HirDatabase) -> ModuleScope {
         self.scope_impl(db)
     }
 
-    pub fn resolve_path(&self, db: &impl HirDatabase, path: &Path) -> Cancelable<PerNs<DefId>> {
+    pub fn resolve_path(&self, db: &impl HirDatabase, path: &Path) -> PerNs<DefId> {
         self.resolve_path_impl(db, path)
     }
 
-    pub fn problems(
-        &self,
-        db: &impl HirDatabase,
-    ) -> Cancelable<Vec<(TreeArc<SyntaxNode>, Problem)>> {
+    pub fn problems(&self, db: &impl HirDatabase) -> Vec<(TreeArc<SyntaxNode>, Problem)> {
         self.problems_impl(db)
     }
 }
@@ -160,7 +157,7 @@ impl StructField {
     pub fn name(&self) -> &Name {
         &self.name
     }
-    pub fn ty(&self, db: &impl HirDatabase) -> Cancelable<Option<Ty>> {
+    pub fn ty(&self, db: &impl HirDatabase) -> Option<Ty> {
         db.type_for_field(self.struct_.def_id, self.name.clone())
     }
 }
@@ -175,13 +172,12 @@ impl Struct {
         self.def_id
     }
 
-    pub fn name(&self, db: &impl HirDatabase) -> Cancelable<Option<Name>> {
-        Ok(db.struct_data(self.def_id)?.name.clone())
+    pub fn name(&self, db: &impl HirDatabase) -> Option<Name> {
+        db.struct_data(self.def_id).name.clone()
     }
 
-    pub fn fields(&self, db: &impl HirDatabase) -> Cancelable<Vec<StructField>> {
-        let res = db
-            .struct_data(self.def_id)?
+    pub fn fields(&self, db: &impl HirDatabase) -> Vec<StructField> {
+        db.struct_data(self.def_id)
             .variant_data
             .fields()
             .iter()
@@ -189,15 +185,11 @@ impl Struct {
                 struct_: self.clone(),
                 name: it.name.clone(),
             })
-            .collect();
-        Ok(res)
+            .collect()
     }
 
-    pub fn source(
-        &self,
-        db: &impl HirDatabase,
-    ) -> Cancelable<(HirFileId, TreeArc<ast::StructDef>)> {
-        Ok(def_id_to_ast(db, self.def_id))
+    pub fn source(&self, db: &impl HirDatabase) -> (HirFileId, TreeArc<ast::StructDef>) {
+        def_id_to_ast(db, self.def_id)
     }
 }
 
@@ -215,16 +207,16 @@ impl Enum {
         self.def_id
     }
 
-    pub fn name(&self, db: &impl HirDatabase) -> Cancelable<Option<Name>> {
-        Ok(db.enum_data(self.def_id)?.name.clone())
+    pub fn name(&self, db: &impl HirDatabase) -> Option<Name> {
+        db.enum_data(self.def_id).name.clone()
     }
 
-    pub fn variants(&self, db: &impl HirDatabase) -> Cancelable<Vec<(Name, EnumVariant)>> {
-        Ok(db.enum_data(self.def_id)?.variants.clone())
+    pub fn variants(&self, db: &impl HirDatabase) -> Vec<(Name, EnumVariant)> {
+        db.enum_data(self.def_id).variants.clone()
     }
 
-    pub fn source(&self, db: &impl HirDatabase) -> Cancelable<(HirFileId, TreeArc<ast::EnumDef>)> {
-        Ok(def_id_to_ast(db, self.def_id))
+    pub fn source(&self, db: &impl HirDatabase) -> (HirFileId, TreeArc<ast::EnumDef>) {
+        def_id_to_ast(db, self.def_id)
     }
 }
 
@@ -242,23 +234,20 @@ impl EnumVariant {
         self.def_id
     }
 
-    pub fn parent_enum(&self, db: &impl HirDatabase) -> Cancelable<Enum> {
-        Ok(db.enum_variant_data(self.def_id)?.parent_enum.clone())
+    pub fn parent_enum(&self, db: &impl HirDatabase) -> Enum {
+        db.enum_variant_data(self.def_id).parent_enum.clone()
     }
 
-    pub fn name(&self, db: &impl HirDatabase) -> Cancelable<Option<Name>> {
-        Ok(db.enum_variant_data(self.def_id)?.name.clone())
+    pub fn name(&self, db: &impl HirDatabase) -> Option<Name> {
+        db.enum_variant_data(self.def_id).name.clone()
     }
 
-    pub fn variant_data(&self, db: &impl HirDatabase) -> Cancelable<Arc<VariantData>> {
-        Ok(db.enum_variant_data(self.def_id)?.variant_data.clone())
+    pub fn variant_data(&self, db: &impl HirDatabase) -> Arc<VariantData> {
+        db.enum_variant_data(self.def_id).variant_data.clone()
     }
 
-    pub fn source(
-        &self,
-        db: &impl HirDatabase,
-    ) -> Cancelable<(HirFileId, TreeArc<ast::EnumVariant>)> {
-        Ok(def_id_to_ast(db, self.def_id))
+    pub fn source(&self, db: &impl HirDatabase) -> (HirFileId, TreeArc<ast::EnumVariant>) {
+        def_id_to_ast(db, self.def_id)
     }
 }
 
@@ -305,28 +294,28 @@ impl Function {
         self.def_id
     }
 
-    pub fn source(&self, db: &impl HirDatabase) -> Cancelable<(HirFileId, TreeArc<ast::FnDef>)> {
-        Ok(def_id_to_ast(db, self.def_id))
+    pub fn source(&self, db: &impl HirDatabase) -> (HirFileId, TreeArc<ast::FnDef>) {
+        def_id_to_ast(db, self.def_id)
     }
 
-    pub fn body_syntax_mapping(&self, db: &impl HirDatabase) -> Cancelable<Arc<BodySyntaxMapping>> {
+    pub fn body_syntax_mapping(&self, db: &impl HirDatabase) -> Arc<BodySyntaxMapping> {
         db.body_syntax_mapping(self.def_id)
     }
 
-    pub fn scopes(&self, db: &impl HirDatabase) -> Cancelable<ScopesWithSyntaxMapping> {
-        let scopes = db.fn_scopes(self.def_id)?;
-        let syntax_mapping = db.body_syntax_mapping(self.def_id)?;
-        Ok(ScopesWithSyntaxMapping {
+    pub fn scopes(&self, db: &impl HirDatabase) -> ScopesWithSyntaxMapping {
+        let scopes = db.fn_scopes(self.def_id);
+        let syntax_mapping = db.body_syntax_mapping(self.def_id);
+        ScopesWithSyntaxMapping {
             scopes,
             syntax_mapping,
-        })
+        }
     }
 
     pub fn signature(&self, db: &impl HirDatabase) -> Arc<FnSignature> {
         db.fn_signature(self.def_id)
     }
 
-    pub fn infer(&self, db: &impl HirDatabase) -> Cancelable<Arc<InferenceResult>> {
+    pub fn infer(&self, db: &impl HirDatabase) -> Arc<InferenceResult> {
         db.infer(self.def_id)
     }
 }
@@ -341,8 +330,8 @@ impl Const {
         Const { def_id }
     }
 
-    pub fn source(&self, db: &impl HirDatabase) -> Cancelable<(HirFileId, TreeArc<ast::ConstDef>)> {
-        Ok(def_id_to_ast(db, self.def_id))
+    pub fn source(&self, db: &impl HirDatabase) -> (HirFileId, TreeArc<ast::ConstDef>) {
+        def_id_to_ast(db, self.def_id)
     }
 }
 
@@ -356,11 +345,8 @@ impl Static {
         Static { def_id }
     }
 
-    pub fn source(
-        &self,
-        db: &impl HirDatabase,
-    ) -> Cancelable<(HirFileId, TreeArc<ast::StaticDef>)> {
-        Ok(def_id_to_ast(db, self.def_id))
+    pub fn source(&self, db: &impl HirDatabase) -> (HirFileId, TreeArc<ast::StaticDef>) {
+        def_id_to_ast(db, self.def_id)
     }
 }
 
@@ -374,8 +360,8 @@ impl Trait {
         Trait { def_id }
     }
 
-    pub fn source(&self, db: &impl HirDatabase) -> Cancelable<(HirFileId, TreeArc<ast::TraitDef>)> {
-        Ok(def_id_to_ast(db, self.def_id))
+    pub fn source(&self, db: &impl HirDatabase) -> (HirFileId, TreeArc<ast::TraitDef>) {
+        def_id_to_ast(db, self.def_id)
     }
 }
 
@@ -389,7 +375,7 @@ impl Type {
         Type { def_id }
     }
 
-    pub fn source(&self, db: &impl HirDatabase) -> Cancelable<(HirFileId, TreeArc<ast::TypeDef>)> {
-        Ok(def_id_to_ast(db, self.def_id))
+    pub fn source(&self, db: &impl HirDatabase) -> (HirFileId, TreeArc<ast::TypeDef>) {
+        def_id_to_ast(db, self.def_id)
     }
 }
diff --git a/crates/ra_hir/src/code_model_impl/function.rs b/crates/ra_hir/src/code_model_impl/function.rs
index 8d6b7fc19..66d7e1713 100644
--- a/crates/ra_hir/src/code_model_impl/function.rs
+++ b/crates/ra_hir/src/code_model_impl/function.rs
@@ -2,7 +2,6 @@ mod scope;
 
 use std::sync::Arc;
 
-use ra_db::Cancelable;
 use ra_syntax::{TreeArc, ast::{self, NameOwner}};
 
 use crate::{
@@ -20,16 +19,16 @@ impl Function {
         Function { def_id }
     }
 
-    pub(crate) fn body(&self, db: &impl HirDatabase) -> Cancelable<Arc<Body>> {
+    pub(crate) fn body(&self, db: &impl HirDatabase) -> Arc<Body> {
         db.body_hir(self.def_id)
     }
 
-    pub(crate) fn module(&self, db: &impl HirDatabase) -> Cancelable<Module> {
+    pub(crate) fn module(&self, db: &impl HirDatabase) -> Module {
         self.def_id.module(db)
     }
 
     /// The containing impl block, if this is a method.
-    pub(crate) fn impl_block(&self, db: &impl HirDatabase) -> Cancelable<Option<ImplBlock>> {
+    pub(crate) fn impl_block(&self, db: &impl HirDatabase) -> Option<ImplBlock> {
         self.def_id.impl_block(db)
     }
 }
diff --git a/crates/ra_hir/src/code_model_impl/krate.rs b/crates/ra_hir/src/code_model_impl/krate.rs
index 3275eafed..8c6e34873 100644
--- a/crates/ra_hir/src/code_model_impl/krate.rs
+++ b/crates/ra_hir/src/code_model_impl/krate.rs
@@ -1,4 +1,4 @@
-use ra_db::{CrateId, Cancelable};
+use ra_db::CrateId;
 
 use crate::{
     HirFileId, Crate, CrateDependency, AsName, DefLoc, DefKind, Module, SourceItemId,
@@ -20,18 +20,18 @@ impl Crate {
             })
             .collect()
     }
-    pub(crate) fn root_module_impl(&self, db: &impl HirDatabase) -> Cancelable<Option<Module>> {
+    pub(crate) fn root_module_impl(&self, db: &impl HirDatabase) -> Option<Module> {
         let crate_graph = db.crate_graph();
         let file_id = crate_graph.crate_root(self.crate_id);
         let source_root_id = db.file_source_root(file_id);
         let file_id = HirFileId::from(file_id);
-        let module_tree = db.module_tree(source_root_id)?;
+        let module_tree = db.module_tree(source_root_id);
         // FIXME: teach module tree about crate roots instead of guessing
         let source = SourceItemId {
             file_id,
             item_id: None,
         };
-        let module_id = ctry!(module_tree.find_module_by_source(source));
+        let module_id = module_tree.find_module_by_source(source)?;
 
         let def_loc = DefLoc {
             kind: DefKind::Module,
@@ -42,6 +42,6 @@ impl Crate {
         let def_id = def_loc.id(db);
 
         let module = Module::new(def_id);
-        Ok(Some(module))
+        Some(module)
     }
 }
diff --git a/crates/ra_hir/src/code_model_impl/module.rs b/crates/ra_hir/src/code_model_impl/module.rs
index 775dd6709..a5c032d69 100644
--- a/crates/ra_hir/src/code_model_impl/module.rs
+++ b/crates/ra_hir/src/code_model_impl/module.rs
@@ -1,4 +1,4 @@
-use ra_db::{Cancelable, SourceRootId, FileId};
+use ra_db::{SourceRootId, FileId};
 use ra_syntax::{ast, SyntaxNode, AstNode, TreeArc};
 
 use crate::{
@@ -18,8 +18,8 @@ impl Module {
         db: &impl HirDatabase,
         source_root_id: SourceRootId,
         module_id: ModuleId,
-    ) -> Cancelable<Self> {
-        let module_tree = db.module_tree(source_root_id)?;
+    ) -> Self {
+        let module_tree = db.module_tree(source_root_id);
         let def_loc = DefLoc {
             kind: DefKind::Module,
             source_root_id,
@@ -27,21 +27,17 @@ impl Module {
             source_item_id: module_id.source(&module_tree),
         };
         let def_id = def_loc.id(db);
-        let module = Module::new(def_id);
-        Ok(module)
+        Module::new(def_id)
     }
 
-    pub(crate) fn name_impl(&self, db: &impl HirDatabase) -> Cancelable<Option<Name>> {
+    pub(crate) fn name_impl(&self, db: &impl HirDatabase) -> Option<Name> {
         let loc = self.def_id.loc(db);
-        let module_tree = db.module_tree(loc.source_root_id)?;
-        let link = ctry!(loc.module_id.parent_link(&module_tree));
-        Ok(Some(link.name(&module_tree).clone()))
+        let module_tree = db.module_tree(loc.source_root_id);
+        let link = loc.module_id.parent_link(&module_tree)?;
+        Some(link.name(&module_tree).clone())
     }
 
-    pub fn definition_source_impl(
-        &self,
-        db: &impl HirDatabase,
-    ) -> Cancelable<(FileId, ModuleSource)> {
+    pub fn definition_source_impl(&self, db: &impl HirDatabase) -> (FileId, ModuleSource) {
         let loc = self.def_id.loc(db);
         let file_id = loc.source_item_id.file_id.as_original_file();
         let syntax_node = db.file_item(loc.source_item_id);
@@ -51,94 +47,89 @@ impl Module {
             let module = ast::Module::cast(&syntax_node).unwrap();
             ModuleSource::Module(module.to_owned())
         };
-        Ok((file_id, module_source))
+        (file_id, module_source)
     }
 
     pub fn declaration_source_impl(
         &self,
         db: &impl HirDatabase,
-    ) -> Cancelable<Option<(FileId, TreeArc<ast::Module>)>> {
+    ) -> Option<(FileId, TreeArc<ast::Module>)> {
         let loc = self.def_id.loc(db);
-        let module_tree = db.module_tree(loc.source_root_id)?;
-        let link = ctry!(loc.module_id.parent_link(&module_tree));
+        let module_tree = db.module_tree(loc.source_root_id);
+        let link = loc.module_id.parent_link(&module_tree)?;
         let file_id = link
             .owner(&module_tree)
             .source(&module_tree)
             .file_id
             .as_original_file();
         let src = link.source(&module_tree, db);
-        Ok(Some((file_id, src)))
+        Some((file_id, src))
     }
 
-    pub(crate) fn krate_impl(&self, db: &impl HirDatabase) -> Cancelable<Option<Crate>> {
-        let root = self.crate_root(db)?;
+    pub(crate) fn krate_impl(&self, db: &impl HirDatabase) -> Option<Crate> {
+        let root = self.crate_root(db);
         let loc = root.def_id.loc(db);
         let file_id = loc.source_item_id.file_id.as_original_file();
 
         let crate_graph = db.crate_graph();
-        let crate_id = ctry!(crate_graph.crate_id_for_crate_root(file_id));
-        Ok(Some(Crate::new(crate_id)))
+        let crate_id = crate_graph.crate_id_for_crate_root(file_id)?;
+        Some(Crate::new(crate_id))
     }
 
-    pub(crate) fn crate_root_impl(&self, db: &impl HirDatabase) -> Cancelable<Module> {
+    pub(crate) fn crate_root_impl(&self, db: &impl HirDatabase) -> Module {
         let loc = self.def_id.loc(db);
-        let module_tree = db.module_tree(loc.source_root_id)?;
+        let module_tree = db.module_tree(loc.source_root_id);
         let module_id = loc.module_id.crate_root(&module_tree);
         Module::from_module_id(db, loc.source_root_id, module_id)
     }
 
     /// Finds a child module with the specified name.
-    pub fn child_impl(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
+    pub fn child_impl(&self, db: &impl HirDatabase, name: &Name) -> Option<Module> {
         let loc = self.def_id.loc(db);
-        let module_tree = db.module_tree(loc.source_root_id)?;
-        let child_id = ctry!(loc.module_id.child(&module_tree, name));
-        Module::from_module_id(db, loc.source_root_id, child_id).map(Some)
+        let module_tree = db.module_tree(loc.source_root_id);
+        let child_id = loc.module_id.child(&module_tree, name)?;
+        Some(Module::from_module_id(db, loc.source_root_id, child_id))
     }
 
     /// Iterates over all child modules.
-    pub fn children_impl(&self, db: &impl HirDatabase) -> Cancelable<impl Iterator<Item = Module>> {
+    pub fn children_impl(&self, db: &impl HirDatabase) -> impl Iterator<Item = Module> {
         // FIXME this should be implementable without collecting into a vec, but
         // it's kind of hard since the iterator needs to keep a reference to the
         // module tree.
         let loc = self.def_id.loc(db);
-        let module_tree = db.module_tree(loc.source_root_id)?;
+        let module_tree = db.module_tree(loc.source_root_id);
         let children = loc
             .module_id
             .children(&module_tree)
             .map(|(_, module_id)| Module::from_module_id(db, loc.source_root_id, module_id))
-            .collect::<Cancelable<Vec<_>>>()?;
-        Ok(children.into_iter())
+            .collect::<Vec<_>>();
+        children.into_iter()
     }
 
-    pub fn parent_impl(&self, db: &impl HirDatabase) -> Cancelable<Option<Module>> {
+    pub fn parent_impl(&self, db: &impl HirDatabase) -> Option<Module> {
         let loc = self.def_id.loc(db);
-        let module_tree = db.module_tree(loc.source_root_id)?;
-        let parent_id = ctry!(loc.module_id.parent(&module_tree));
-        Module::from_module_id(db, loc.source_root_id, parent_id).map(Some)
+        let module_tree = db.module_tree(loc.source_root_id);
+        let parent_id = loc.module_id.parent(&module_tree)?;
+        Some(Module::from_module_id(db, loc.source_root_id, parent_id))
     }
 
     /// Returns a `ModuleScope`: a set of items, visible in this module.
-    pub fn scope_impl(&self, db: &impl HirDatabase) -> Cancelable<ModuleScope> {
+    pub fn scope_impl(&self, db: &impl HirDatabase) -> ModuleScope {
         let loc = self.def_id.loc(db);
-        let item_map = db.item_map(loc.source_root_id)?;
-        let res = item_map.per_module[&loc.module_id].clone();
-        Ok(res)
+        let item_map = db.item_map(loc.source_root_id);
+        item_map.per_module[&loc.module_id].clone()
     }
 
-    pub fn resolve_path_impl(
-        &self,
-        db: &impl HirDatabase,
-        path: &Path,
-    ) -> Cancelable<PerNs<DefId>> {
+    pub fn resolve_path_impl(&self, db: &impl HirDatabase, path: &Path) -> PerNs<DefId> {
         let mut curr_per_ns = PerNs::types(
             match path.kind {
-                PathKind::Crate => self.crate_root(db)?,
+                PathKind::Crate => self.crate_root(db),
                 PathKind::Self_ | PathKind::Plain => self.clone(),
                 PathKind::Super => {
-                    if let Some(p) = self.parent(db)? {
+                    if let Some(p) = self.parent(db) {
                         p
                     } else {
-                        return Ok(PerNs::none());
+                        return PerNs::none();
                     }
                 }
             }
@@ -150,47 +141,44 @@ impl Module {
             let curr = if let Some(r) = curr_per_ns.as_ref().take_types() {
                 r
             } else {
-                return Ok(PerNs::none());
+                return PerNs::none();
             };
-            let module = match curr.resolve(db)? {
+            let module = match curr.resolve(db) {
                 Def::Module(it) => it,
                 Def::Enum(e) => {
                     if segments.len() == idx + 1 {
                         // enum variant
                         let matching_variant =
-                            e.variants(db)?.into_iter().find(|(n, _variant)| n == name);
+                            e.variants(db).into_iter().find(|(n, _variant)| n == name);
 
                         if let Some((_n, variant)) = matching_variant {
-                            return Ok(PerNs::both(variant.def_id(), e.def_id()));
+                            return PerNs::both(variant.def_id(), e.def_id());
                         } else {
-                            return Ok(PerNs::none());
+                            return PerNs::none();
                         }
                     } else if segments.len() == idx {
                         // enum
-                        return Ok(PerNs::types(e.def_id()));
+                        return PerNs::types(e.def_id());
                     } else {
                         // malformed enum?
-                        return Ok(PerNs::none());
+                        return PerNs::none();
                     }
                 }
-                _ => return Ok(PerNs::none()),
+                _ => return PerNs::none(),
             };
-            let scope = module.scope(db)?;
+            let scope = module.scope(db);
             curr_per_ns = if let Some(r) = scope.get(&name) {
                 r.def_id
             } else {
-                return Ok(PerNs::none());
+                return PerNs::none();
             };
         }
-        Ok(curr_per_ns)
+        curr_per_ns
     }
 
-    pub fn problems_impl(
-        &self,
-        db: &impl HirDatabase,
-    ) -> Cancelable<Vec<(TreeArc<SyntaxNode>, Problem)>> {
+    pub fn problems_impl(&self, db: &impl HirDatabase) -> Vec<(TreeArc<SyntaxNode>, Problem)> {
         let loc = self.def_id.loc(db);
-        let module_tree = db.module_tree(loc.source_root_id)?;
-        Ok(loc.module_id.problems(&module_tree, db))
+        let module_tree = db.module_tree(loc.source_root_id);
+        loc.module_id.problems(&module_tree, db)
     }
 }
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index fd6336dd8..0a0994f5f 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
 use ra_syntax::{SyntaxNode, TreeArc, SourceFile};
-use ra_db::{SourceRootId, LocationIntener, SyntaxDatabase, Cancelable};
+use ra_db::{SourceRootId, LocationIntener, SyntaxDatabase};
 
 use crate::{
     DefLoc, DefId, MacroCallLoc, MacroCallId, Name, HirFileId,
@@ -32,37 +32,37 @@ pub trait HirDatabase: SyntaxDatabase
         use fn crate::macros::expand_macro_invocation;
     }
 
-    fn fn_scopes(def_id: DefId) -> Cancelable<Arc<FnScopes>> {
+    fn fn_scopes(def_id: DefId) -> Arc<FnScopes> {
         type FnScopesQuery;
         use fn query_definitions::fn_scopes;
     }
 
-    fn struct_data(def_id: DefId) -> Cancelable<Arc<StructData>> {
+    fn struct_data(def_id: DefId) -> Arc<StructData> {
         type StructDataQuery;
         use fn crate::adt::StructData::struct_data_query;
     }
 
-    fn enum_data(def_id: DefId) -> Cancelable<Arc<EnumData>> {
+    fn enum_data(def_id: DefId) -> Arc<EnumData> {
         type EnumDataQuery;
         use fn crate::adt::EnumData::enum_data_query;
     }
 
-    fn enum_variant_data(def_id: DefId) -> Cancelable<Arc<EnumVariantData>> {
+    fn enum_variant_data(def_id: DefId) -> Arc<EnumVariantData> {
         type EnumVariantDataQuery;
         use fn crate::adt::EnumVariantData::enum_variant_data_query;
     }
 
-    fn infer(def_id: DefId) -> Cancelable<Arc<InferenceResult>> {
+    fn infer(def_id: DefId) -> Arc<InferenceResult> {
         type InferQuery;
         use fn crate::ty::infer;
     }
 
-    fn type_for_def(def_id: DefId) -> Cancelable<Ty> {
+    fn type_for_def(def_id: DefId) -> Ty {
         type TypeForDefQuery;
         use fn crate::ty::type_for_def;
     }
 
-    fn type_for_field(def_id: DefId, field: Name) -> Cancelable<Option<Ty>> {
+    fn type_for_field(def_id: DefId, field: Name) -> Option<Ty> {
         type TypeForFieldQuery;
         use fn crate::ty::type_for_field;
     }
@@ -77,42 +77,42 @@ pub trait HirDatabase: SyntaxDatabase
         use fn query_definitions::file_item;
     }
 
-    fn submodules(source: SourceItemId) -> Cancelable<Arc<Vec<crate::module_tree::Submodule>>> {
+    fn submodules(source: SourceItemId) -> Arc<Vec<crate::module_tree::Submodule>> {
         type SubmodulesQuery;
         use fn crate::module_tree::Submodule::submodules_query;
     }
 
-    fn input_module_items(source_root_id: SourceRootId, module_id: ModuleId) -> Cancelable<Arc<InputModuleItems>> {
+    fn input_module_items(source_root_id: SourceRootId, module_id: ModuleId) -> Arc<InputModuleItems> {
         type InputModuleItemsQuery;
         use fn query_definitions::input_module_items;
     }
 
-    fn item_map(source_root_id: SourceRootId) -> Cancelable<Arc<ItemMap>> {
+    fn item_map(source_root_id: SourceRootId) -> Arc<ItemMap> {
         type ItemMapQuery;
         use fn query_definitions::item_map;
     }
 
-    fn module_tree(source_root_id: SourceRootId) -> Cancelable<Arc<ModuleTree>> {
+    fn module_tree(source_root_id: SourceRootId) -> Arc<ModuleTree> {
         type ModuleTreeQuery;
         use fn crate::module_tree::ModuleTree::module_tree_query;
     }
 
-    fn impls_in_module(source_root_id: SourceRootId, module_id: ModuleId) -> Cancelable<Arc<ModuleImplBlocks>> {
+    fn impls_in_module(source_root_id: SourceRootId, module_id: ModuleId) -> Arc<ModuleImplBlocks> {
         type ImplsInModuleQuery;
         use fn crate::impl_block::impls_in_module;
     }
 
-    fn impls_in_crate(krate: Crate) -> Cancelable<Arc<CrateImplBlocks>> {
+    fn impls_in_crate(krate: Crate) -> Arc<CrateImplBlocks> {
         type ImplsInCrateQuery;
         use fn crate::ty::method_resolution::CrateImplBlocks::impls_in_crate_query;
     }
 
-    fn body_hir(def_id: DefId) -> Cancelable<Arc<crate::expr::Body>> {
+    fn body_hir(def_id: DefId) -> Arc<crate::expr::Body> {
         type BodyHirQuery;
         use fn crate::expr::body_hir;
     }
 
-    fn body_syntax_mapping(def_id: DefId) -> Cancelable<Arc<crate::expr::BodySyntaxMapping>> {
+    fn body_syntax_mapping(def_id: DefId) -> Arc<crate::expr::BodySyntaxMapping> {
         type BodySyntaxMappingQuery;
         use fn crate::expr::body_syntax_mapping;
     }
diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs
index f0936e9f3..663338844 100644
--- a/crates/ra_hir/src/expr.rs
+++ b/crates/ra_hir/src/expr.rs
@@ -4,10 +4,11 @@ use std::sync::Arc;
 use rustc_hash::FxHashMap;
 
 use ra_arena::{Arena, RawId, impl_arena_id, map::ArenaMap};
-use ra_db::{LocalSyntaxPtr, Cancelable};
-use ra_syntax::ast::{self, AstNode, LoopBodyOwner, ArgListOwner, NameOwner};
+use ra_db::LocalSyntaxPtr;
+use ra_syntax::ast::{self, AstNode, LoopBodyOwner, ArgListOwner, NameOwner, LiteralFlavor};
 
 use crate::{Path, type_ref::{Mutability, TypeRef}, Name, HirDatabase, DefId, Def, name::AsName};
+use crate::ty::primitive::{UintTy, UncertainIntTy, UncertainFloatTy};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct ExprId(RawId);
@@ -104,6 +105,16 @@ impl BodySyntaxMapping {
 }
 
 #[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,
@@ -171,7 +182,7 @@ pub enum Expr {
     },
     UnaryOp {
         expr: ExprId,
-        op: Option<UnaryOp>,
+        op: UnaryOp,
     },
     BinaryOp {
         lhs: ExprId,
@@ -186,6 +197,7 @@ pub enum Expr {
     Tuple {
         exprs: Vec<ExprId>,
     },
+    Literal(Literal),
 }
 
 pub use ra_syntax::ast::PrefixOp as UnaryOp;
@@ -305,6 +317,7 @@ impl Expr {
                     f(*expr);
                 }
             }
+            Expr::Literal(_) => {}
         }
     }
 }
@@ -343,8 +356,8 @@ impl Pat {
 
 // Queries
 
-pub(crate) fn body_hir(db: &impl HirDatabase, def_id: DefId) -> Cancelable<Arc<Body>> {
-    Ok(Arc::clone(&body_syntax_mapping(db, def_id)?.body))
+pub(crate) fn body_hir(db: &impl HirDatabase, def_id: DefId) -> Arc<Body> {
+    Arc::clone(&body_syntax_mapping(db, def_id).body)
 }
 
 struct ExprCollector {
@@ -599,8 +612,11 @@ impl ExprCollector {
             }
             ast::ExprKind::PrefixExpr(e) => {
                 let expr = self.collect_expr_opt(e.expr());
-                let op = e.op();
-                self.alloc_expr(Expr::UnaryOp { expr, op }, syntax_ptr)
+                if let Some(op) = e.op() {
+                    self.alloc_expr(Expr::UnaryOp { expr, op }, syntax_ptr)
+                } else {
+                    self.alloc_expr(Expr::Missing, syntax_ptr)
+                }
             }
             ast::ExprKind::LambdaExpr(e) => {
                 let mut args = Vec::new();
@@ -633,13 +649,50 @@ impl ExprCollector {
                 let exprs = e.exprs().map(|expr| self.collect_expr(expr)).collect();
                 self.alloc_expr(Expr::Tuple { exprs }, syntax_ptr)
             }
+            ast::ExprKind::Literal(e) => {
+                let child = if let Some(child) = e.literal_expr() {
+                    child
+                } else {
+                    return self.alloc_expr(Expr::Missing, syntax_ptr);
+                };
+
+                let lit = match child.flavor() {
+                    LiteralFlavor::IntNumber { suffix } => {
+                        let known_name = suffix
+                            .map(|s| Name::new(s))
+                            .and_then(|name| UncertainIntTy::from_name(&name));
+
+                        Literal::Int(
+                            Default::default(),
+                            known_name.unwrap_or(UncertainIntTy::Unknown),
+                        )
+                    }
+                    LiteralFlavor::FloatNumber { suffix } => {
+                        let known_name = suffix
+                            .map(|s| Name::new(s))
+                            .and_then(|name| UncertainFloatTy::from_name(&name));
+
+                        Literal::Float(
+                            Default::default(),
+                            known_name.unwrap_or(UncertainFloatTy::Unknown),
+                        )
+                    }
+                    LiteralFlavor::ByteString => Literal::ByteString(Default::default()),
+                    LiteralFlavor::String => Literal::String(Default::default()),
+                    LiteralFlavor::Byte => {
+                        Literal::Int(Default::default(), UncertainIntTy::Unsigned(UintTy::U8))
+                    }
+                    LiteralFlavor::Bool => Literal::Bool(Default::default()),
+                    LiteralFlavor::Char => Literal::Char(Default::default()),
+                };
+                self.alloc_expr(Expr::Literal(lit), syntax_ptr)
+            }
 
             // TODO implement HIR for these:
             ast::ExprKind::Label(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
             ast::ExprKind::IndexExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
             ast::ExprKind::ArrayExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
             ast::ExprKind::RangeExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
-            ast::ExprKind::Literal(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
         }
     }
 
@@ -776,17 +829,14 @@ pub(crate) fn collect_fn_body_syntax(node: &ast::FnDef) -> BodySyntaxMapping {
     collector.into_body_syntax_mapping(params, body)
 }
 
-pub(crate) fn body_syntax_mapping(
-    db: &impl HirDatabase,
-    def_id: DefId,
-) -> Cancelable<Arc<BodySyntaxMapping>> {
-    let def = def_id.resolve(db)?;
+pub(crate) fn body_syntax_mapping(db: &impl HirDatabase, def_id: DefId) -> Arc<BodySyntaxMapping> {
+    let def = def_id.resolve(db);
 
     let body_syntax_mapping = match def {
-        Def::Function(f) => collect_fn_body_syntax(&f.source(db)?.1),
+        Def::Function(f) => collect_fn_body_syntax(&f.source(db).1),
         // TODO: consts, etc.
         _ => panic!("Trying to get body for item type without body"),
     };
 
-    Ok(Arc::new(body_syntax_mapping))
+    Arc::new(body_syntax_mapping)
 }
diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs
index 316896dce..0d8e67547 100644
--- a/crates/ra_hir/src/ids.rs
+++ b/crates/ra_hir/src/ids.rs
@@ -1,4 +1,4 @@
-use ra_db::{SourceRootId, LocationIntener, Cancelable, FileId};
+use ra_db::{SourceRootId, LocationIntener, FileId};
 use ra_syntax::{TreeArc, SyntaxKind, SyntaxNode, SourceFile, AstNode, ast};
 use ra_arena::{Arena, RawId, impl_arena_id};
 
@@ -159,11 +159,11 @@ impl DefId {
         db.as_ref().id2loc(self)
     }
 
-    pub fn resolve(self, db: &impl HirDatabase) -> Cancelable<Def> {
+    pub fn resolve(self, db: &impl HirDatabase) -> Def {
         let loc = self.loc(db);
-        let res = match loc.kind {
+        match loc.kind {
             DefKind::Module => {
-                let module = Module::from_module_id(db, loc.source_root_id, loc.module_id)?;
+                let module = Module::from_module_id(db, loc.source_root_id, loc.module_id);
                 Def::Module(module)
             }
             DefKind::Function => {
@@ -195,8 +195,7 @@ impl DefId {
 
             DefKind::StructCtor => Def::Item,
             DefKind::Item => Def::Item,
-        };
-        Ok(res)
+        }
     }
 
     pub(crate) fn source(self, db: &impl HirDatabase) -> (HirFileId, TreeArc<SyntaxNode>) {
@@ -206,21 +205,21 @@ impl DefId {
     }
 
     /// For a module, returns that module; for any other def, returns the containing module.
-    pub fn module(self, db: &impl HirDatabase) -> Cancelable<Module> {
+    pub fn module(self, db: &impl HirDatabase) -> Module {
         let loc = self.loc(db);
         Module::from_module_id(db, loc.source_root_id, loc.module_id)
     }
 
     /// Returns the containing crate.
-    pub fn krate(&self, db: &impl HirDatabase) -> Cancelable<Option<Crate>> {
-        Ok(self.module(db)?.krate(db)?)
+    pub fn krate(&self, db: &impl HirDatabase) -> Option<Crate> {
+        self.module(db).krate(db)
     }
 
     /// Returns the containing impl block, if this is an impl item.
-    pub fn impl_block(self, db: &impl HirDatabase) -> Cancelable<Option<ImplBlock>> {
+    pub fn impl_block(self, db: &impl HirDatabase) -> Option<ImplBlock> {
         let loc = self.loc(db);
-        let module_impls = db.impls_in_module(loc.source_root_id, loc.module_id)?;
-        Ok(ImplBlock::containing(module_impls, self))
+        let module_impls = db.impls_in_module(loc.source_root_id, loc.module_id);
+        ImplBlock::containing(module_impls, self)
     }
 }
 
diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs
index d0b086308..ab996a12c 100644
--- a/crates/ra_hir/src/impl_block.rs
+++ b/crates/ra_hir/src/impl_block.rs
@@ -3,7 +3,7 @@ use rustc_hash::FxHashMap;
 
 use ra_arena::{Arena, RawId, impl_arena_id};
 use ra_syntax::ast::{self, AstNode};
-use ra_db::{LocationIntener, Cancelable, SourceRootId};
+use ra_db::{LocationIntener, SourceRootId};
 
 use crate::{
     DefId, DefLoc, DefKind, SourceItemId, SourceFileItems,
@@ -166,8 +166,8 @@ impl ModuleImplBlocks {
         }
     }
 
-    fn collect(&mut self, db: &impl HirDatabase, module: Module) -> Cancelable<()> {
-        let (file_id, module_source) = module.definition_source(db)?;
+    fn collect(&mut self, db: &impl HirDatabase, module: Module) {
+        let (file_id, module_source) = module.definition_source(db);
         let node = match &module_source {
             ModuleSource::SourceFile(node) => node.syntax(),
             ModuleSource::Module(node) => node
@@ -185,8 +185,6 @@ impl ModuleImplBlocks {
                 self.impls_by_def.insert(impl_item.def_id(), id);
             }
         }
-
-        Ok(())
     }
 }
 
@@ -194,9 +192,9 @@ pub(crate) fn impls_in_module(
     db: &impl HirDatabase,
     source_root_id: SourceRootId,
     module_id: ModuleId,
-) -> Cancelable<Arc<ModuleImplBlocks>> {
+) -> Arc<ModuleImplBlocks> {
     let mut result = ModuleImplBlocks::new();
-    let module = Module::from_module_id(db, source_root_id, module_id)?;
-    result.collect(db, module)?;
-    Ok(Arc::new(result))
+    let module = Module::from_module_id(db, source_root_id, module_id);
+    result.collect(db, module);
+    Arc::new(result)
 }
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 45dda4f7f..ef7d049ee 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -5,15 +5,6 @@
 //! to a particular crate instance. That is, it has cfg flags and features
 //! applied. So, the relation between syntax and HIR is many-to-one.
 
-macro_rules! ctry {
-    ($expr:expr) => {
-        match $expr {
-            None => return Ok(None),
-            Some(it) => it,
-        }
-    };
-}
-
 pub mod db;
 #[cfg(test)]
 mod mock;
diff --git a/crates/ra_hir/src/module_tree.rs b/crates/ra_hir/src/module_tree.rs
index 67823e970..0256d7996 100644
--- a/crates/ra_hir/src/module_tree.rs
+++ b/crates/ra_hir/src/module_tree.rs
@@ -3,7 +3,7 @@ use std::sync::Arc;
 use rustc_hash::{FxHashMap, FxHashSet};
 use arrayvec::ArrayVec;
 use relative_path::RelativePathBuf;
-use ra_db::{FileId, SourceRootId, Cancelable, SourceRoot};
+use ra_db::{FileId, SourceRootId, SourceRoot};
 use ra_syntax::{
     SyntaxNode, TreeArc,
     algo::generate,
@@ -41,8 +41,8 @@ impl Submodule {
     pub(crate) fn submodules_query(
         db: &impl HirDatabase,
         source: SourceItemId,
-    ) -> Cancelable<Arc<Vec<Submodule>>> {
-        db.check_canceled()?;
+    ) -> Arc<Vec<Submodule>> {
+        db.check_canceled();
         let file_id = source.file_id;
         let file_items = db.file_items(file_id);
         let module_source = ModuleSource::from_source_item_id(db, source);
@@ -54,7 +54,7 @@ impl Submodule {
                 collect_submodules(file_id, &file_items, module.item_list().unwrap())
             }
         };
-        return Ok(Arc::new(submodules));
+        return Arc::new(submodules);
 
         fn collect_submodules(
             file_id: HirFileId,
@@ -116,10 +116,10 @@ impl ModuleTree {
     pub(crate) fn module_tree_query(
         db: &impl HirDatabase,
         source_root: SourceRootId,
-    ) -> Cancelable<Arc<ModuleTree>> {
-        db.check_canceled()?;
+    ) -> Arc<ModuleTree> {
+        db.check_canceled();
         let res = create_module_tree(db, source_root);
-        Ok(Arc::new(res?))
+        Arc::new(res)
     }
 
     pub(crate) fn modules<'a>(&'a self) -> impl Iterator<Item = ModuleId> + 'a {
@@ -225,10 +225,7 @@ fn modules(root: &impl ast::ModuleItemOwner) -> impl Iterator<Item = (Name, &ast
         })
 }
 
-fn create_module_tree<'a>(
-    db: &impl HirDatabase,
-    source_root: SourceRootId,
-) -> Cancelable<ModuleTree> {
+fn create_module_tree<'a>(db: &impl HirDatabase, source_root: SourceRootId) -> ModuleTree {
     let mut tree = ModuleTree::default();
 
     let mut roots = FxHashMap::default();
@@ -252,10 +249,10 @@ fn create_module_tree<'a>(
             &mut roots,
             None,
             source,
-        )?;
+        );
         roots.insert(file_id, module_id);
     }
-    Ok(tree)
+    tree
 }
 
 fn build_subtree(
@@ -266,14 +263,14 @@ fn build_subtree(
     roots: &mut FxHashMap<FileId, ModuleId>,
     parent: Option<LinkId>,
     source: SourceItemId,
-) -> Cancelable<ModuleId> {
+) -> ModuleId {
     visited.insert(source);
     let id = tree.push_mod(ModuleData {
         source,
         parent,
         children: Vec::new(),
     });
-    for sub in db.submodules(source)?.iter() {
+    for sub in db.submodules(source).iter() {
         let link = tree.push_link(LinkData {
             source: sub.source,
             name: sub.name.clone(),
@@ -289,7 +286,7 @@ fn build_subtree(
                 .map(|file_id| match roots.remove(&file_id) {
                     Some(module_id) => {
                         tree.mods[module_id].parent = Some(link);
-                        Ok(module_id)
+                        module_id
                     }
                     None => build_subtree(
                         db,
@@ -304,7 +301,7 @@ fn build_subtree(
                         },
                     ),
                 })
-                .collect::<Cancelable<Vec<_>>>()?;
+                .collect::<Vec<_>>();
             (points_to, problem)
         } else {
             let points_to = build_subtree(
@@ -315,14 +312,14 @@ fn build_subtree(
                 roots,
                 Some(link),
                 sub.source,
-            )?;
+            );
             (vec![points_to], None)
         };
 
         tree.links[link].points_to = points_to;
         tree.links[link].problem = problem;
     }
-    Ok(id)
+    id
 }
 
 fn resolve_submodule(
diff --git a/crates/ra_hir/src/name.rs b/crates/ra_hir/src/name.rs
index d9683549c..8d786d2ac 100644
--- a/crates/ra_hir/src/name.rs
+++ b/crates/ra_hir/src/name.rs
@@ -23,7 +23,7 @@ impl fmt::Debug for Name {
 }
 
 impl Name {
-    fn new(text: SmolStr) -> Name {
+    pub(crate) fn new(text: SmolStr) -> Name {
         Name { text }
     }
 
diff --git a/crates/ra_hir/src/nameres.rs b/crates/ra_hir/src/nameres.rs
index 6bf949654..484f668d0 100644
--- a/crates/ra_hir/src/nameres.rs
+++ b/crates/ra_hir/src/nameres.rs
@@ -22,7 +22,7 @@ use ra_syntax::{
     SyntaxKind::{self, *},
     ast::{self, AstNode}
 };
-use ra_db::{SourceRootId, Cancelable, FileId};
+use ra_db::{SourceRootId, FileId};
 
 use crate::{
     HirFileId,
@@ -319,30 +319,26 @@ where
         }
     }
 
-    pub(crate) fn resolve(mut self) -> Cancelable<ItemMap> {
+    pub(crate) fn resolve(mut self) -> ItemMap {
         for (&module_id, items) in self.input.iter() {
-            self.populate_module(module_id, Arc::clone(items))?;
+            self.populate_module(module_id, Arc::clone(items));
         }
 
         loop {
             let processed_imports_count = self.processed_imports.len();
             for &module_id in self.input.keys() {
-                self.db.check_canceled()?;
-                self.resolve_imports(module_id)?;
+                self.db.check_canceled();
+                self.resolve_imports(module_id);
             }
             if processed_imports_count == self.processed_imports.len() {
                 // no new imports resolved
                 break;
             }
         }
-        Ok(self.result)
+        self.result
     }
 
-    fn populate_module(
-        &mut self,
-        module_id: ModuleId,
-        input: Arc<InputModuleItems>,
-    ) -> Cancelable<()> {
+    fn populate_module(&mut self, module_id: ModuleId, input: Arc<InputModuleItems>) {
         let mut module_items = ModuleScope::default();
 
         // Populate extern crates prelude
@@ -353,8 +349,8 @@ where
             if let Some(crate_id) = crate_graph.crate_id_for_crate_root(file_id.as_original_file())
             {
                 let krate = Crate::new(crate_id);
-                for dep in krate.dependencies(self.db)? {
-                    if let Some(module) = dep.krate.root_module(self.db)? {
+                for dep in krate.dependencies(self.db) {
+                    if let Some(module) = dep.krate.root_module(self.db) {
                         let def_id = module.def_id;
                         self.add_module_item(
                             &mut module_items,
@@ -415,7 +411,6 @@ where
         }
 
         self.result.per_module.insert(module_id, module_items);
-        Ok(())
     }
 
     fn add_module_item(&self, module_items: &mut ModuleScope, name: Name, def_id: PerNs<DefId>) {
@@ -426,24 +421,23 @@ where
         module_items.items.insert(name, resolution);
     }
 
-    fn resolve_imports(&mut self, module_id: ModuleId) -> Cancelable<()> {
+    fn resolve_imports(&mut self, module_id: ModuleId) {
         for (i, import) in self.input[&module_id].imports.iter().enumerate() {
             if self.processed_imports.contains(&(module_id, i)) {
                 // already done
                 continue;
             }
-            if self.resolve_import(module_id, import)? {
+            if self.resolve_import(module_id, import) {
                 log::debug!("import {:?} resolved (or definite error)", import);
                 self.processed_imports.insert((module_id, i));
             }
         }
-        Ok(())
     }
 
-    fn resolve_import(&mut self, module_id: ModuleId, import: &Import) -> Cancelable<bool> {
+    fn resolve_import(&mut self, module_id: ModuleId, import: &Import) -> bool {
         log::debug!("resolving import: {:?}", import);
         let ptr = match import.kind {
-            ImportKind::Glob => return Ok(false),
+            ImportKind::Glob => return false,
             ImportKind::Named(ptr) => ptr,
         };
 
@@ -455,7 +449,7 @@ where
                     None => {
                         // TODO: error
                         log::debug!("super path in root module");
-                        return Ok(true); // this can't suddenly resolve if we just resolve some other imports
+                        return true; // this can't suddenly resolve if we just resolve some other imports
                     }
                 }
             }
@@ -469,7 +463,7 @@ where
                 Some(res) if !res.def_id.is_none() => res.def_id,
                 _ => {
                     log::debug!("path segment {:?} not found", name);
-                    return Ok(false);
+                    return false;
                 }
             };
 
@@ -481,7 +475,7 @@ where
                         "path segment {:?} resolved to value only, but is not last",
                         name
                     );
-                    return Ok(false);
+                    return false;
                 };
                 curr = match type_def_id.loc(self.db) {
                     DefLoc {
@@ -499,7 +493,7 @@ where
                                 kind: PathKind::Crate,
                             };
                             log::debug!("resolving {:?} in other source root", path);
-                            let def_id = module.resolve_path(self.db, &path)?;
+                            let def_id = module.resolve_path(self.db, &path);
                             if !def_id.is_none() {
                                 let name = path.segments.last().unwrap();
                                 self.update(module_id, |items| {
@@ -515,10 +509,10 @@ where
                                     import,
                                     def_id.map(|did| did.loc(self.db))
                                 );
-                                return Ok(true);
+                                return true;
                             } else {
                                 log::debug!("rest of path did not resolve in other source root");
-                                return Ok(true);
+                                return true;
                             }
                         }
                     }
@@ -528,7 +522,7 @@ where
                             name,
                             type_def_id.loc(self.db)
                         );
-                        return Ok(true); // this resolved to a non-module, so the path won't ever resolve
+                        return true; // this resolved to a non-module, so the path won't ever resolve
                     }
                 }
             } else {
@@ -547,7 +541,7 @@ where
                 })
             }
         }
-        Ok(true)
+        true
     }
 
     fn update(&mut self, module_id: ModuleId, f: impl FnOnce(&mut ModuleScope)) {
diff --git a/crates/ra_hir/src/nameres/tests.rs b/crates/ra_hir/src/nameres/tests.rs
index 647fd92aa..9a0474045 100644
--- a/crates/ra_hir/src/nameres/tests.rs
+++ b/crates/ra_hir/src/nameres/tests.rs
@@ -15,11 +15,9 @@ use crate::{
 fn item_map(fixture: &str) -> (Arc<ItemMap>, ModuleId) {
     let (db, pos) = MockDatabase::with_position(fixture);
     let source_root = db.file_source_root(pos.file_id);
-    let module = crate::source_binder::module_from_position(&db, pos)
-        .unwrap()
-        .unwrap();
+    let module = crate::source_binder::module_from_position(&db, pos).unwrap();
     let module_id = module.def_id.loc(&db).module_id;
-    (db.item_map(source_root).unwrap(), module_id)
+    (db.item_map(source_root), module_id)
 }
 
 fn check_module_item_map(map: &ItemMap, module_id: ModuleId, expected: &str) {
@@ -242,11 +240,9 @@ fn item_map_across_crates() {
     db.set_crate_graph(crate_graph);
 
     let source_root = db.file_source_root(main_id);
-    let module = crate::source_binder::module_from_file_id(&db, main_id)
-        .unwrap()
-        .unwrap();
+    let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
     let module_id = module.def_id.loc(&db).module_id;
-    let item_map = db.item_map(source_root).unwrap();
+    let item_map = db.item_map(source_root);
 
     check_module_item_map(
         &item_map,
@@ -296,11 +292,9 @@ fn import_across_source_roots() {
 
     db.set_crate_graph(crate_graph);
 
-    let module = crate::source_binder::module_from_file_id(&db, main_id)
-        .unwrap()
-        .unwrap();
+    let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
     let module_id = module.def_id.loc(&db).module_id;
-    let item_map = db.item_map(source_root).unwrap();
+    let item_map = db.item_map(source_root);
 
     check_module_item_map(
         &item_map,
@@ -341,11 +335,9 @@ fn reexport_across_crates() {
     db.set_crate_graph(crate_graph);
 
     let source_root = db.file_source_root(main_id);
-    let module = crate::source_binder::module_from_file_id(&db, main_id)
-        .unwrap()
-        .unwrap();
+    let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
     let module_id = module.def_id.loc(&db).module_id;
-    let item_map = db.item_map(source_root).unwrap();
+    let item_map = db.item_map(source_root);
 
     check_module_item_map(
         &item_map,
@@ -362,7 +354,7 @@ fn check_item_map_is_not_recomputed(initial: &str, file_change: &str) {
     let source_root = db.file_source_root(pos.file_id);
     {
         let events = db.log_executed(|| {
-            db.item_map(source_root).unwrap();
+            db.item_map(source_root);
         });
         assert!(format!("{:?}", events).contains("item_map"))
     }
@@ -371,7 +363,7 @@ fn check_item_map_is_not_recomputed(initial: &str, file_change: &str) {
 
     {
         let events = db.log_executed(|| {
-            db.item_map(source_root).unwrap();
+            db.item_map(source_root);
         });
         assert!(
             !format!("{:?}", events).contains("item_map"),
diff --git a/crates/ra_hir/src/query_definitions.rs b/crates/ra_hir/src/query_definitions.rs
index 214a9d68b..24cb5c752 100644
--- a/crates/ra_hir/src/query_definitions.rs
+++ b/crates/ra_hir/src/query_definitions.rs
@@ -8,7 +8,7 @@ use ra_syntax::{
     AstNode, SyntaxNode, TreeArc,
     ast::{self, ModuleItemOwner}
 };
-use ra_db::{SourceRootId, Cancelable,};
+use ra_db::SourceRootId;
 
 use crate::{
     SourceFileItems, SourceItemId, DefId, HirFileId, ModuleSource,
@@ -18,10 +18,10 @@ use crate::{
     nameres::{InputModuleItems, ItemMap, Resolver},
 };
 
-pub(super) fn fn_scopes(db: &impl HirDatabase, def_id: DefId) -> Cancelable<Arc<FnScopes>> {
-    let body = db.body_hir(def_id)?;
+pub(super) fn fn_scopes(db: &impl HirDatabase, def_id: DefId) -> Arc<FnScopes> {
+    let body = db.body_hir(def_id);
     let res = FnScopes::new(body);
-    Ok(Arc::new(res))
+    Arc::new(res)
 }
 
 pub(super) fn file_items(db: &impl HirDatabase, file_id: HirFileId) -> Arc<SourceFileItems> {
@@ -47,8 +47,8 @@ pub(super) fn input_module_items(
     db: &impl HirDatabase,
     source_root_id: SourceRootId,
     module_id: ModuleId,
-) -> Cancelable<Arc<InputModuleItems>> {
-    let module_tree = db.module_tree(source_root_id)?;
+) -> Arc<InputModuleItems> {
+    let module_tree = db.module_tree(source_root_id);
     let source = module_id.source(&module_tree);
     let file_id = source.file_id;
     let source = ModuleSource::from_source_item_id(db, source);
@@ -90,26 +90,20 @@ pub(super) fn input_module_items(
             }
         }
     };
-    Ok(Arc::new(res))
+    Arc::new(res)
 }
 
-pub(super) fn item_map(
-    db: &impl HirDatabase,
-    source_root: SourceRootId,
-) -> Cancelable<Arc<ItemMap>> {
+pub(super) fn item_map(db: &impl HirDatabase, source_root: SourceRootId) -> Arc<ItemMap> {
     let start = Instant::now();
-    let module_tree = db.module_tree(source_root)?;
+    let module_tree = db.module_tree(source_root);
     let input = module_tree
         .modules()
-        .map(|id| {
-            let items = db.input_module_items(source_root, id)?;
-            Ok((id, items))
-        })
-        .collect::<Cancelable<FxHashMap<_, _>>>()?;
+        .map(|id| (id, db.input_module_items(source_root, id)))
+        .collect::<FxHashMap<_, _>>();
 
     let resolver = Resolver::new(db, &input, source_root, module_tree);
-    let res = resolver.resolve()?;
+    let res = resolver.resolve();
     let elapsed = start.elapsed();
     log::info!("item_map: {:?}", elapsed);
-    Ok(Arc::new(res))
+    Arc::new(res)
 }
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index 1f149a366..7ab8eeae2 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -5,7 +5,7 @@
 ///
 /// So, this modules should not be used during hir construction, it exists
 /// purely for "IDE needs".
-use ra_db::{FileId, FilePosition, Cancelable};
+use ra_db::{FileId, FilePosition};
 use ra_syntax::{
     SmolStr, TextRange, SyntaxNode,
     ast::{self, AstNode, NameOwner},
@@ -18,7 +18,7 @@ use crate::{
 };
 
 /// Locates the module by `FileId`. Picks topmost module in the file.
-pub fn module_from_file_id(db: &impl HirDatabase, file_id: FileId) -> Cancelable<Option<Module>> {
+pub fn module_from_file_id(db: &impl HirDatabase, file_id: FileId) -> Option<Module> {
     let module_source = SourceItemId {
         file_id: file_id.into(),
         item_id: None,
@@ -31,25 +31,22 @@ pub fn module_from_declaration(
     db: &impl HirDatabase,
     file_id: FileId,
     decl: &ast::Module,
-) -> Cancelable<Option<Module>> {
-    let parent_module = module_from_file_id(db, file_id)?;
+) -> Option<Module> {
+    let parent_module = module_from_file_id(db, file_id);
     let child_name = decl.name();
     match (parent_module, child_name) {
         (Some(parent_module), Some(child_name)) => {
-            if let Some(child) = parent_module.child(db, &child_name.as_name())? {
-                return Ok(Some(child));
+            if let Some(child) = parent_module.child(db, &child_name.as_name()) {
+                return Some(child);
             }
         }
         _ => (),
     }
-    Ok(None)
+    None
 }
 
 /// Locates the module by position in the source code.
-pub fn module_from_position(
-    db: &impl HirDatabase,
-    position: FilePosition,
-) -> Cancelable<Option<Module>> {
+pub fn module_from_position(db: &impl HirDatabase, position: FilePosition) -> Option<Module> {
     let file = db.source_file(position.file_id);
     match find_node_at_offset::<ast::Module>(file.syntax(), position.offset) {
         Some(m) if !m.has_semi() => module_from_inline(db, position.file_id.into(), m),
@@ -61,7 +58,7 @@ fn module_from_inline(
     db: &impl HirDatabase,
     file_id: FileId,
     module: &ast::Module,
-) -> Cancelable<Option<Module>> {
+) -> Option<Module> {
     assert!(!module.has_semi());
     let file_id = file_id.into();
     let file_items = db.file_items(file_id);
@@ -78,7 +75,7 @@ pub fn module_from_child_node(
     db: &impl HirDatabase,
     file_id: FileId,
     child: &SyntaxNode,
-) -> Cancelable<Option<Module>> {
+) -> Option<Module> {
     if let Some(m) = child
         .ancestors()
         .filter_map(ast::Module::cast)
@@ -90,22 +87,16 @@ pub fn module_from_child_node(
     }
 }
 
-fn module_from_source(db: &impl HirDatabase, source: SourceItemId) -> Cancelable<Option<Module>> {
+fn module_from_source(db: &impl HirDatabase, source: SourceItemId) -> Option<Module> {
     let source_root_id = db.file_source_root(source.file_id.as_original_file());
-    let module_tree = db.module_tree(source_root_id)?;
-    let module_id = ctry!(module_tree.find_module_by_source(source));
-    Ok(Some(Module::from_module_id(db, source_root_id, module_id)?))
+    let module_tree = db.module_tree(source_root_id);
+    let module_id = module_tree.find_module_by_source(source)?;
+    Some(Module::from_module_id(db, source_root_id, module_id))
 }
 
-pub fn function_from_position(
-    db: &impl HirDatabase,
-    position: FilePosition,
-) -> Cancelable<Option<Function>> {
+pub fn function_from_position(db: &impl HirDatabase, position: FilePosition) -> Option<Function> {
     let file = db.source_file(position.file_id);
-    let fn_def = ctry!(find_node_at_offset::<ast::FnDef>(
-        file.syntax(),
-        position.offset
-    ));
+    let fn_def = find_node_at_offset::<ast::FnDef>(file.syntax(), position.offset)?;
     function_from_source(db, position.file_id, fn_def)
 }
 
@@ -113,10 +104,10 @@ pub fn function_from_source(
     db: &impl HirDatabase,
     file_id: FileId,
     fn_def: &ast::FnDef,
-) -> Cancelable<Option<Function>> {
-    let module = ctry!(module_from_child_node(db, file_id, fn_def.syntax())?);
+) -> Option<Function> {
+    let module = module_from_child_node(db, file_id, fn_def.syntax())?;
     let res = function_from_module(db, &module, fn_def);
-    Ok(Some(res))
+    Some(res)
 }
 
 pub fn function_from_module(
@@ -145,21 +136,18 @@ pub fn function_from_child_node(
     db: &impl HirDatabase,
     file_id: FileId,
     node: &SyntaxNode,
-) -> Cancelable<Option<Function>> {
-    let fn_def = ctry!(node.ancestors().find_map(ast::FnDef::cast));
+) -> Option<Function> {
+    let fn_def = node.ancestors().find_map(ast::FnDef::cast)?;
     function_from_source(db, file_id, fn_def)
 }
 
-pub fn macro_symbols(
-    db: &impl HirDatabase,
-    file_id: FileId,
-) -> Cancelable<Vec<(SmolStr, TextRange)>> {
-    let module = match module_from_file_id(db, file_id)? {
+pub fn macro_symbols(db: &impl HirDatabase, file_id: FileId) -> Vec<(SmolStr, TextRange)> {
+    let module = match module_from_file_id(db, file_id) {
         Some(it) => it,
-        None => return Ok(Vec::new()),
+        None => return Vec::new(),
     };
     let loc = module.def_id.loc(db);
-    let items = db.input_module_items(loc.source_root_id, loc.module_id)?;
+    let items = db.input_module_items(loc.source_root_id, loc.module_id);
     let mut res = Vec::new();
 
     for macro_call_id in items
@@ -184,5 +172,5 @@ pub fn macro_symbols(
         }
     }
 
-    Ok(res)
+    res
 }
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())
 }
diff --git a/crates/ra_hir/src/ty/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs
index 7c3839388..b221bd142 100644
--- a/crates/ra_hir/src/ty/method_resolution.rs
+++ b/crates/ra_hir/src/ty/method_resolution.rs
@@ -6,7 +6,7 @@ use std::sync::Arc;
 
 use rustc_hash::FxHashMap;
 
-use ra_db::{Cancelable, SourceRootId};
+use ra_db::SourceRootId;
 
 use crate::{HirDatabase, DefId, module_tree::ModuleId, Module, Crate, Name, Function, impl_block::{ImplId, ImplBlock, ImplItem}};
 use super::Ty;
@@ -42,21 +42,21 @@ impl CrateImplBlocks {
         &'a self,
         db: &'a impl HirDatabase,
         ty: &Ty,
-    ) -> impl Iterator<Item = Cancelable<ImplBlock>> + 'a {
+    ) -> impl Iterator<Item = ImplBlock> + 'a {
         let fingerprint = TyFingerprint::for_impl(ty);
         fingerprint
             .and_then(|f| self.impls.get(&f))
             .into_iter()
             .flat_map(|i| i.iter())
             .map(move |(module_id, impl_id)| {
-                let module_impl_blocks = db.impls_in_module(self.source_root_id, *module_id)?;
-                Ok(ImplBlock::from_id(module_impl_blocks, *impl_id))
+                let module_impl_blocks = db.impls_in_module(self.source_root_id, *module_id);
+                ImplBlock::from_id(module_impl_blocks, *impl_id)
             })
     }
 
-    fn collect_recursive(&mut self, db: &impl HirDatabase, module: Module) -> Cancelable<()> {
+    fn collect_recursive(&mut self, db: &impl HirDatabase, module: Module) {
         let module_id = module.def_id.loc(db).module_id;
-        let module_impl_blocks = db.impls_in_module(self.source_root_id, module_id)?;
+        let module_impl_blocks = db.impls_in_module(self.source_root_id, module_id);
 
         for (impl_id, impl_data) in module_impl_blocks.impls.iter() {
             let impl_block = ImplBlock::from_id(Arc::clone(&module_impl_blocks), impl_id);
@@ -65,7 +65,7 @@ impl CrateImplBlocks {
                 // ignore for now
             } else {
                 let target_ty =
-                    Ty::from_hir(db, &module, Some(&impl_block), impl_data.target_type())?;
+                    Ty::from_hir(db, &module, Some(&impl_block), impl_data.target_type());
                 if let Some(target_ty_fp) = TyFingerprint::for_impl(&target_ty) {
                     self.impls
                         .entry(target_ty_fp)
@@ -75,17 +75,15 @@ impl CrateImplBlocks {
             }
         }
 
-        for child in module.children(db)? {
-            self.collect_recursive(db, child)?;
+        for child in module.children(db) {
+            self.collect_recursive(db, child);
         }
-
-        Ok(())
     }
 
     pub(crate) fn impls_in_crate_query(
         db: &impl HirDatabase,
         krate: Crate,
-    ) -> Cancelable<Arc<CrateImplBlocks>> {
+    ) -> Arc<CrateImplBlocks> {
         let crate_graph = db.crate_graph();
         let file_id = crate_graph.crate_root(krate.crate_id);
         let source_root_id = db.file_source_root(file_id);
@@ -93,17 +91,17 @@ impl CrateImplBlocks {
             source_root_id,
             impls: FxHashMap::default(),
         };
-        if let Some(module) = krate.root_module(db)? {
-            crate_impl_blocks.collect_recursive(db, module)?;
+        if let Some(module) = krate.root_module(db) {
+            crate_impl_blocks.collect_recursive(db, module);
         }
-        Ok(Arc::new(crate_impl_blocks))
+        Arc::new(crate_impl_blocks)
     }
 }
 
-fn def_crate(db: &impl HirDatabase, ty: &Ty) -> Cancelable<Option<Crate>> {
+fn def_crate(db: &impl HirDatabase, ty: &Ty) -> Option<Crate> {
     match ty {
         Ty::Adt { def_id, .. } => def_id.krate(db),
-        _ => Ok(None),
+        _ => None,
     }
 }
 
@@ -111,13 +109,13 @@ impl Ty {
     // TODO: cache this as a query?
     // - if so, what signature? (TyFingerprint, Name)?
     // - or maybe cache all names and def_ids of methods per fingerprint?
-    pub fn lookup_method(self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<DefId>> {
+    pub fn lookup_method(self, db: &impl HirDatabase, name: &Name) -> Option<DefId> {
         self.iterate_methods(db, |f| {
             let sig = f.signature(db);
             if sig.name() == name && sig.has_self_param() {
-                Ok(Some(f.def_id()))
+                Some(f.def_id())
             } else {
-                Ok(None)
+                None
             }
         })
     }
@@ -127,8 +125,8 @@ impl Ty {
     pub fn iterate_methods<T>(
         self,
         db: &impl HirDatabase,
-        mut callback: impl FnMut(Function) -> Cancelable<Option<T>>,
-    ) -> Cancelable<Option<T>> {
+        mut callback: impl FnMut(Function) -> Option<T>,
+    ) -> Option<T> {
         // For method calls, rust first does any number of autoderef, and then one
         // autoref (i.e. when the method takes &self or &mut self). We just ignore
         // the autoref currently -- when we find a method matching the given name,
@@ -139,19 +137,18 @@ impl Ty {
         // rustc does an autoderef and then autoref again).
 
         for derefed_ty in self.autoderef(db) {
-            let krate = match def_crate(db, &derefed_ty)? {
+            let krate = match def_crate(db, &derefed_ty) {
                 Some(krate) => krate,
                 None => continue,
             };
-            let impls = db.impls_in_crate(krate)?;
+            let impls = db.impls_in_crate(krate);
 
             for impl_block in impls.lookup_impl_blocks(db, &derefed_ty) {
-                let impl_block = impl_block?;
                 for item in impl_block.items() {
                     match item {
                         ImplItem::Method(f) => {
-                            if let Some(result) = callback(f.clone())? {
-                                return Ok(Some(result));
+                            if let Some(result) = callback(f.clone()) {
+                                return Some(result);
                             }
                         }
                         _ => {}
@@ -159,6 +156,6 @@ impl Ty {
                 }
             }
         }
-        Ok(None)
+        None
     }
 }
diff --git a/crates/ra_hir/src/ty/primitive.rs b/crates/ra_hir/src/ty/primitive.rs
index 498d42d52..5741ca90d 100644
--- a/crates/ra_hir/src/ty/primitive.rs
+++ b/crates/ra_hir/src/ty/primitive.rs
@@ -2,6 +2,56 @@ use std::fmt;
 
 use crate::{Name, KnownName};
 
+#[derive(Debug, Clone, Eq, PartialEq, Hash, Copy)]
+pub enum UncertainIntTy {
+    Unknown,
+    Unsigned(UintTy),
+    Signed(IntTy),
+}
+
+impl UncertainIntTy {
+    pub fn ty_to_string(&self) -> &'static str {
+        match *self {
+            UncertainIntTy::Unknown => "{integer}",
+            UncertainIntTy::Signed(ty) => ty.ty_to_string(),
+            UncertainIntTy::Unsigned(ty) => ty.ty_to_string(),
+        }
+    }
+
+    pub fn from_name(name: &Name) -> Option<UncertainIntTy> {
+        if let Some(ty) = IntTy::from_name(name) {
+            Some(UncertainIntTy::Signed(ty))
+        } else if let Some(ty) = UintTy::from_name(name) {
+            Some(UncertainIntTy::Unsigned(ty))
+        } else {
+            None
+        }
+    }
+}
+
+#[derive(Debug, Clone, Eq, PartialEq, Hash, Copy)]
+pub enum UncertainFloatTy {
+    Unknown,
+    Known(FloatTy),
+}
+
+impl UncertainFloatTy {
+    pub fn ty_to_string(&self) -> &'static str {
+        match *self {
+            UncertainFloatTy::Unknown => "{float}",
+            UncertainFloatTy::Known(ty) => ty.ty_to_string(),
+        }
+    }
+
+    pub fn from_name(name: &Name) -> Option<UncertainFloatTy> {
+        if let Some(ty) = FloatTy::from_name(name) {
+            Some(UncertainFloatTy::Known(ty))
+        } else {
+            None
+        }
+    }
+}
+
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Copy)]
 pub enum IntTy {
     Isize,
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index 920188fc9..5d7bc25cc 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -133,6 +133,55 @@ fn test(a: &u32, b: &mut u32, c: *const u32, d: *mut u32) {
 }
 
 #[test]
+fn infer_literals() {
+    check_inference(
+        r##"
+fn test() {
+    5i32;
+    "hello";
+    b"bytes";
+    'c';
+    b'b';
+    3.14;
+    5000;
+    false;
+    true;
+    r#"
+        //! doc
+        // non-doc
+        mod foo {}
+        "#;
+    br#"yolo"#;
+}
+"##,
+        "literals.txt",
+    );
+}
+
+#[test]
+fn infer_unary_op() {
+    check_inference(
+        r#"
+enum SomeType {}
+
+fn test(x: SomeType) {
+    let b = false;
+    let c = !b;
+    let a = 100;
+    let d: i128 = -a;
+    let e = -100;
+    let f = !!!true;
+    -3.14;
+    -x;
+    !x;
+    -"hello";
+}
+"#,
+        "unary_op.txt",
+    );
+}
+
+#[test]
 fn infer_backwards() {
     check_inference(
         r#"
@@ -180,7 +229,7 @@ fn f(x: bool) -> i32 {
     0i32
 }
 
-fn test() {
+fn test() -> bool {
     let x = a && b;
     let y = true || false;
     let z = x == y;
@@ -277,8 +326,6 @@ fn test(x: &str, y: isize) {
     let b = (a, x);
     let c = (y, x);
     let d = (c, x);
-
-    // we have not infered these case yet.
     let e = (1, "e");
     let f = (e, "d");
 }
@@ -296,11 +343,9 @@ fn infer(content: &str) -> String {
         .descendants()
         .filter_map(ast::FnDef::cast)
     {
-        let func = source_binder::function_from_source(&db, file_id, fn_def)
-            .unwrap()
-            .unwrap();
-        let inference_result = func.infer(&db).unwrap();
-        let body_syntax_mapping = func.body_syntax_mapping(&db).unwrap();
+        let func = source_binder::function_from_source(&db, file_id, fn_def).unwrap();
+        let inference_result = func.infer(&db);
+        let body_syntax_mapping = func.body_syntax_mapping(&db);
         let mut types = Vec::new();
         for (pat, ty) in inference_result.type_of_pat.iter() {
             let syntax_ptr = match body_syntax_mapping.pat_syntax(pat) {
@@ -380,12 +425,10 @@ fn typing_whitespace_inside_a_function_should_not_invalidate_types() {
         }
     ",
     );
-    let func = source_binder::function_from_position(&db, pos)
-        .unwrap()
-        .unwrap();
+    let func = source_binder::function_from_position(&db, pos).unwrap();
     {
         let events = db.log_executed(|| {
-            func.infer(&db).unwrap();
+            func.infer(&db);
         });
         assert!(format!("{:?}", events).contains("infer"))
     }
@@ -404,7 +447,7 @@ fn typing_whitespace_inside_a_function_should_not_invalidate_types() {
 
     {
         let events = db.log_executed(|| {
-            func.infer(&db).unwrap();
+            func.infer(&db);
         });
         assert!(!format!("{:?}", events).contains("infer"), "{:#?}", events)
     }
diff --git a/crates/ra_hir/src/ty/tests/data/basics.txt b/crates/ra_hir/src/ty/tests/data/basics.txt
index ac7faae0a..e65fe07aa 100644
--- a/crates/ra_hir/src/ty/tests/data/basics.txt
+++ b/crates/ra_hir/src/ty/tests/data/basics.txt
@@ -7,7 +7,7 @@
 [55; 56) 'b': isize
 [62; 63) 'c': !
 [69; 70) 'd': &str
-[76; 82) '1usize': [unknown]
-[88; 94) '1isize': [unknown]
-[100; 106) '"test"': [unknown]
-[112; 118) '1.0f32': [unknown]
+[76; 82) '1usize': usize
+[88; 94) '1isize': isize
+[100; 106) '"test"': &str
+[112; 118) '1.0f32': f32
diff --git a/crates/ra_hir/src/ty/tests/data/binary_op.txt b/crates/ra_hir/src/ty/tests/data/binary_op.txt
index 8a515ac5e..58a727691 100644
--- a/crates/ra_hir/src/ty/tests/data/binary_op.txt
+++ b/crates/ra_hir/src/ty/tests/data/binary_op.txt
@@ -1,46 +1,46 @@
 [6; 7) 'x': bool
 [22; 34) '{     0i32 }': i32
 [28; 32) '0i32': i32
-[46; 342) '{     ... < 3 }': bool
-[56; 57) 'x': bool
-[60; 61) 'a': bool
-[60; 66) 'a && b': bool
-[65; 66) 'b': bool
-[76; 77) 'y': bool
-[80; 84) 'true': bool
-[80; 93) 'true || false': bool
-[88; 93) 'false': bool
-[103; 104) 'z': bool
-[107; 108) 'x': bool
-[107; 113) 'x == y': bool
-[112; 113) 'y': bool
-[123; 134) 'minus_forty': isize
-[144; 152) '-40isize': isize
-[145; 152) '40isize': [unknown]
-[162; 163) 'h': bool
-[166; 177) 'minus_forty': isize
-[166; 188) 'minus_...ONST_2': bool
-[181; 188) 'CONST_2': isize
-[198; 199) 'c': i32
-[202; 203) 'f': fn(bool) -> i32
-[202; 211) 'f(z || y)': i32
-[202; 215) 'f(z || y) + 5': i32
-[204; 205) 'z': bool
-[204; 210) 'z || y': bool
-[209; 210) 'y': bool
-[214; 215) '5': i32
-[225; 226) 'd': [unknown]
-[229; 230) 'b': [unknown]
-[240; 241) 'g': ()
-[244; 255) 'minus_forty': isize
-[244; 260) 'minus_...y ^= i': ()
-[259; 260) 'i': isize
-[270; 273) 'ten': usize
-[283; 285) '10': usize
-[295; 308) 'ten_is_eleven': bool
-[311; 314) 'ten': usize
-[311; 326) 'ten == some_num': bool
-[318; 326) 'some_num': usize
-[333; 336) 'ten': usize
-[333; 340) 'ten < 3': bool
-[339; 340) '3': usize
+[54; 350) '{     ... < 3 }': bool
+[64; 65) 'x': bool
+[68; 69) 'a': bool
+[68; 74) 'a && b': bool
+[73; 74) 'b': bool
+[84; 85) 'y': bool
+[88; 92) 'true': bool
+[88; 101) 'true || false': bool
+[96; 101) 'false': bool
+[111; 112) 'z': bool
+[115; 116) 'x': bool
+[115; 121) 'x == y': bool
+[120; 121) 'y': bool
+[131; 142) 'minus_forty': isize
+[152; 160) '-40isize': isize
+[153; 160) '40isize': isize
+[170; 171) 'h': bool
+[174; 185) 'minus_forty': isize
+[174; 196) 'minus_...ONST_2': bool
+[189; 196) 'CONST_2': isize
+[206; 207) 'c': i32
+[210; 211) 'f': fn(bool) -> i32
+[210; 219) 'f(z || y)': i32
+[210; 223) 'f(z || y) + 5': i32
+[212; 213) 'z': bool
+[212; 218) 'z || y': bool
+[217; 218) 'y': bool
+[222; 223) '5': i32
+[233; 234) 'd': [unknown]
+[237; 238) 'b': [unknown]
+[248; 249) 'g': ()
+[252; 263) 'minus_forty': isize
+[252; 268) 'minus_...y ^= i': ()
+[267; 268) 'i': isize
+[278; 281) 'ten': usize
+[291; 293) '10': usize
+[303; 316) 'ten_is_eleven': bool
+[319; 322) 'ten': usize
+[319; 334) 'ten == some_num': bool
+[326; 334) 'some_num': usize
+[341; 344) 'ten': usize
+[341; 348) 'ten < 3': bool
+[347; 348) '3': usize
diff --git a/crates/ra_hir/src/ty/tests/data/let.txt b/crates/ra_hir/src/ty/tests/data/let.txt
index 30f4a2cf5..8815dba41 100644
--- a/crates/ra_hir/src/ty/tests/data/let.txt
+++ b/crates/ra_hir/src/ty/tests/data/let.txt
@@ -1,6 +1,6 @@
 [11; 71) '{     ...= b; }': ()
-[21; 22) 'a': [unknown]
-[25; 31) '1isize': [unknown]
+[21; 22) 'a': isize
+[25; 31) '1isize': isize
 [41; 42) 'b': usize
 [52; 53) '1': usize
 [63; 64) 'c': usize
diff --git a/crates/ra_hir/src/ty/tests/data/literals.txt b/crates/ra_hir/src/ty/tests/data/literals.txt
new file mode 100644
index 000000000..84ee2c11b
--- /dev/null
+++ b/crates/ra_hir/src/ty/tests/data/literals.txt
@@ -0,0 +1,12 @@
+[11; 201) '{     ...o"#; }': ()
+[17; 21) '5i32': i32
+[27; 34) '"hello"': &str
+[40; 48) 'b"bytes"': &[u8]
+[54; 57) ''c'': char
+[63; 67) 'b'b'': u8
+[73; 77) '3.14': f64
+[83; 87) '5000': i32
+[93; 98) 'false': bool
+[104; 108) 'true': bool
+[114; 182) 'r#"   ...    "#': &str
+[188; 198) 'br#"yolo"#': &[u8]
diff --git a/crates/ra_hir/src/ty/tests/data/struct.txt b/crates/ra_hir/src/ty/tests/data/struct.txt
index 7b324c82f..be9e12d02 100644
--- a/crates/ra_hir/src/ty/tests/data/struct.txt
+++ b/crates/ra_hir/src/ty/tests/data/struct.txt
@@ -2,14 +2,14 @@
 [82; 83) 'c': [unknown]
 [86; 87) 'C': [unknown]
 [86; 90) 'C(1)': [unknown]
-[88; 89) '1': [unknown]
+[88; 89) '1': i32
 [96; 97) 'B': [unknown]
 [107; 108) 'a': A
 [114; 133) 'A { b:...C(1) }': A
 [121; 122) 'B': B
 [127; 128) 'C': [unknown]
 [127; 131) 'C(1)': C
-[129; 130) '1': [unknown]
+[129; 130) '1': i32
 [139; 140) 'a': A
 [139; 142) 'a.b': B
 [148; 149) 'a': A
diff --git a/crates/ra_hir/src/ty/tests/data/tuple.txt b/crates/ra_hir/src/ty/tests/data/tuple.txt
index 96169180d..a95d3c286 100644
--- a/crates/ra_hir/src/ty/tests/data/tuple.txt
+++ b/crates/ra_hir/src/ty/tests/data/tuple.txt
@@ -1,6 +1,6 @@
 [9; 10) 'x': &str
 [18; 19) 'y': isize
-[28; 214) '{     ...d"); }': ()
+[28; 170) '{     ...d"); }': ()
 [38; 39) 'a': (u32, &str)
 [55; 63) '(1, "a")': (u32, &str)
 [56; 57) '1': u32
@@ -17,11 +17,11 @@
 [117; 123) '(c, x)': ((isize, &str), &str)
 [118; 119) 'c': (isize, &str)
 [121; 122) 'x': &str
-[177; 178) 'e': ([unknown], [unknown])
-[181; 189) '(1, "e")': ([unknown], [unknown])
-[182; 183) '1': [unknown]
-[185; 188) '"e"': [unknown]
-[199; 200) 'f': (([unknown], [unknown]), [unknown])
-[203; 211) '(e, "d")': (([unknown], [unknown]), [unknown])
-[204; 205) 'e': ([unknown], [unknown])
-[207; 210) '"d"': [unknown]
+[133; 134) 'e': (i32, &str)
+[137; 145) '(1, "e")': (i32, &str)
+[138; 139) '1': i32
+[141; 144) '"e"': &str
+[155; 156) 'f': ((i32, &str), &str)
+[159; 167) '(e, "d")': ((i32, &str), &str)
+[160; 161) 'e': (i32, &str)
+[163; 166) '"d"': &str
diff --git a/crates/ra_hir/src/ty/tests/data/unary_op.txt b/crates/ra_hir/src/ty/tests/data/unary_op.txt
new file mode 100644
index 000000000..203022e82
--- /dev/null
+++ b/crates/ra_hir/src/ty/tests/data/unary_op.txt
@@ -0,0 +1,28 @@
+[27; 28) 'x': SomeType
+[40; 197) '{     ...lo"; }': ()
+[50; 51) 'b': bool
+[54; 59) 'false': bool
+[69; 70) 'c': bool
+[73; 75) '!b': bool
+[74; 75) 'b': bool
+[85; 86) 'a': i128
+[89; 92) '100': i128
+[102; 103) 'd': i128
+[112; 114) '-a': i128
+[113; 114) 'a': i128
+[124; 125) 'e': i32
+[128; 132) '-100': i32
+[129; 132) '100': i32
+[142; 143) 'f': bool
+[146; 153) '!!!true': bool
+[147; 153) '!!true': bool
+[148; 153) '!true': bool
+[149; 153) 'true': bool
+[159; 164) '-3.14': f64
+[160; 164) '3.14': f64
+[170; 172) '-x': [unknown]
+[171; 172) 'x': SomeType
+[178; 180) '!x': [unknown]
+[179; 180) 'x': SomeType
+[186; 194) '-"hello"': [unknown]
+[187; 194) '"hello"': &str