29 files changed, 673 insertions, 316 deletions

diff --git a/crates/ra_assists/src/flip_eq_operands.rs b/crates/ra_assists/src/flip_eq_operands.rs
new file mode 100644
index 000000000..df0bb689d
--- /dev/null
+++ b/crates/ra_assists/src/flip_eq_operands.rs
@@ -0,0 +1,86 @@
+use hir::db::HirDatabase;
+use ra_syntax::ast::{AstNode, BinExpr, BinOp};
+
+use crate::{AssistCtx, Assist, AssistId};
+
+pub(crate) fn flip_eq_operands(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+    let expr = ctx.node_at_offset::<BinExpr>()?;
+    let lhs = expr.lhs()?.syntax();
+    let rhs = expr.rhs()?.syntax();
+    let op_range = expr.op()?.range();
+    let cursor_in_range = ctx.frange.range.is_subrange(&op_range);
+    let allowed_ops = [BinOp::EqualityTest, BinOp::NegatedEqualityTest];
+    let expr_op = expr.op_kind()?;
+    if !cursor_in_range || !allowed_ops.iter().any(|o| *o == expr_op) {
+        return None;
+    }
+    ctx.add_action(AssistId("flip_eq_operands"), "flip equality operands", |edit| {
+        edit.target(op_range);
+        edit.replace(lhs.range(), rhs.text());
+        edit.replace(rhs.range(), lhs.text());
+    });
+
+    ctx.build()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use crate::helpers::{check_assist, check_assist_target};
+
+    #[test]
+    fn flip_eq_operands_for_simple_stmt() {
+        check_assist(
+            flip_eq_operands,
+            "fn f() { let res = 1 ==<|> 2; }",
+            "fn f() { let res = 2 ==<|> 1; }",
+        )
+    }
+
+    #[test]
+    fn flip_neq_operands_for_simple_stmt() {
+        check_assist(
+            flip_eq_operands,
+            "fn f() { let res = 1 !=<|> 2; }",
+            "fn f() { let res = 2 !=<|> 1; }",
+        )
+    }
+
+    #[test]
+    fn flip_eq_operands_for_complex_stmt() {
+        check_assist(
+            flip_eq_operands,
+            "fn f() { let res = (1 + 1) ==<|> (2 + 2); }",
+            "fn f() { let res = (2 + 2) ==<|> (1 + 1); }",
+        )
+    }
+
+    #[test]
+    fn flip_eq_operands_in_match_expr() {
+        check_assist(
+            flip_eq_operands,
+            r#"
+            fn dyn_eq(&self, other: &dyn Diagnostic) -> bool {
+                match other.downcast_ref::<Self>() {
+                    None => false,
+                    Some(it) => it ==<|> self,
+                }
+            }
+            "#,
+            r#"
+            fn dyn_eq(&self, other: &dyn Diagnostic) -> bool {
+                match other.downcast_ref::<Self>() {
+                    None => false,
+                    Some(it) => self ==<|> it,
+                }
+            }
+            "#,
+        )
+    }
+
+    #[test]
+    fn flip_eq_operands_target() {
+        check_assist_target(flip_eq_operands, "fn f() { let res = 1 ==<|> 2; }", "==")
+    }
+}
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index 378470ac8..2e47b5215 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -88,6 +88,7 @@ where
 mod add_derive;
 mod add_impl;
 mod flip_comma;
+mod flip_eq_operands;
 mod change_visibility;
 mod fill_match_arms;
 mod fill_struct_fields;
@@ -107,6 +108,7 @@ fn all_assists<DB: HirDatabase>() -> &'static [fn(AssistCtx<DB>) -> Option<Assis
         fill_match_arms::fill_match_arms,
         fill_struct_fields::fill_struct_fields,
         flip_comma::flip_comma,
+        flip_eq_operands::flip_eq_operands,
         introduce_variable::introduce_variable,
         replace_if_let_with_match::replace_if_let_with_match,
         split_import::split_import,
diff --git a/crates/ra_cli/Cargo.toml b/crates/ra_cli/Cargo.toml
index 4c666f556..467628236 100644
--- a/crates/ra_cli/Cargo.toml
+++ b/crates/ra_cli/Cargo.toml
@@ -14,7 +14,6 @@ indicatif = "0.11.0"
 
 ra_syntax = { path = "../ra_syntax" }
 ra_ide_api = { path = "../ra_ide_api" }
-ra_ide_api_light = { path = "../ra_ide_api_light" }
 tools = { path = "../tools" }
 ra_batch = { path = "../ra_batch" }
 ra_hir = { path = "../ra_hir" }
diff --git a/crates/ra_cli/src/main.rs b/crates/ra_cli/src/main.rs
index 5285f1f28..11f5541eb 100644
--- a/crates/ra_cli/src/main.rs
+++ b/crates/ra_cli/src/main.rs
@@ -5,7 +5,7 @@ use std::{fs, io::Read, path::Path, time::Instant};
 use clap::{App, Arg, SubCommand};
 use join_to_string::join;
 use ra_ide_api::{Analysis, FileRange};
-use ra_ide_api_light::file_structure;
+use ra_ide_api::file_structure;
 use ra_syntax::{SourceFile, TextRange, TreeArc, AstNode};
 use tools::collect_tests;
 use flexi_logger::Logger;
diff --git a/crates/ra_hir/src/code_model_api.rs b/crates/ra_hir/src/code_model_api.rs
index 45fa4cd11..5437133b8 100644
--- a/crates/ra_hir/src/code_model_api.rs
+++ b/crates/ra_hir/src/code_model_api.rs
@@ -1,8 +1,7 @@
 use std::sync::Arc;
 
-use relative_path::RelativePathBuf;
 use ra_db::{CrateId, SourceRootId, Edition};
-use ra_syntax::{ast::self, TreeArc, SyntaxNode};
+use ra_syntax::{ast::self, TreeArc};
 
 use crate::{
     Name, ScopesWithSourceMap, Ty, HirFileId,
@@ -17,6 +16,7 @@ use crate::{
     ids::{FunctionId, StructId, EnumId, AstItemDef, ConstId, StaticId, TraitId, TypeId},
     impl_block::ImplBlock,
     resolve::Resolver,
+    diagnostics::DiagnosticSink,
 };
 
 /// hir::Crate describes a single crate. It's the main interface with which
@@ -95,11 +95,6 @@ pub enum ModuleSource {
     Module(TreeArc<ast::Module>),
 }
 
-#[derive(Clone, Debug, Hash, PartialEq, Eq)]
-pub enum Problem {
-    UnresolvedModule { candidate: RelativePathBuf },
-}
-
 impl Module {
     /// Name of this module.
     pub fn name(&self, db: &impl HirDatabase) -> Option<Name> {
@@ -171,8 +166,24 @@ impl Module {
         db.crate_def_map(self.krate)[self.module_id].scope.clone()
     }
 
-    pub fn problems(&self, db: &impl HirDatabase) -> Vec<(TreeArc<SyntaxNode>, Problem)> {
-        self.problems_impl(db)
+    pub fn diagnostics(&self, db: &impl HirDatabase, sink: &mut DiagnosticSink) {
+        db.crate_def_map(self.krate).add_diagnostics(db, self.module_id, sink);
+        for decl in self.declarations(db) {
+            match decl {
+                crate::ModuleDef::Function(f) => f.diagnostics(db, sink),
+                crate::ModuleDef::Module(f) => f.diagnostics(db, sink),
+                _ => (),
+            }
+        }
+
+        for impl_block in self.impl_blocks(db) {
+            for item in impl_block.items(db) {
+                match item {
+                    crate::ImplItem::Method(f) => f.diagnostics(db, sink),
+                    _ => (),
+                }
+            }
+        }
     }
 
     pub fn resolver(&self, db: &impl HirDatabase) -> Resolver {
@@ -519,6 +530,10 @@ impl Function {
         let r = if !p.params.is_empty() { r.push_generic_params_scope(p) } else { r };
         r
     }
+
+    pub fn diagnostics(&self, db: &impl HirDatabase, sink: &mut DiagnosticSink) {
+        self.infer(db).add_diagnostics(db, *self, sink);
+    }
 }
 
 impl Docs for Function {
diff --git a/crates/ra_hir/src/code_model_impl/module.rs b/crates/ra_hir/src/code_model_impl/module.rs
index 52a33e981..14237060c 100644
--- a/crates/ra_hir/src/code_model_impl/module.rs
+++ b/crates/ra_hir/src/code_model_impl/module.rs
@@ -1,8 +1,8 @@
 use ra_db::FileId;
-use ra_syntax::{ast, SyntaxNode, TreeArc, AstNode};
+use ra_syntax::{ast, TreeArc, AstNode};
 
 use crate::{
-    Module, ModuleSource, Problem, Name,
+    Module, ModuleSource, Name,
     nameres::{CrateModuleId, ImportId},
     HirDatabase, DefDatabase,
     HirFileId, SourceItemId,
@@ -108,19 +108,4 @@ impl Module {
         let parent_id = def_map[self.module_id].parent?;
         Some(self.with_module_id(parent_id))
     }
-
-    pub(crate) fn problems_impl(
-        &self,
-        db: &impl HirDatabase,
-    ) -> Vec<(TreeArc<SyntaxNode>, Problem)> {
-        let def_map = db.crate_def_map(self.krate);
-        let (my_file_id, _) = self.definition_source(db);
-        // FIXME: not entirely corret filterint by module
-        def_map
-            .problems()
-            .iter()
-            .filter(|(source_item_id, _problem)| my_file_id == source_item_id.file_id)
-            .map(|(source_item_id, problem)| (db.file_item(*source_item_id), problem.clone()))
-            .collect()
-    }
 }
diff --git a/crates/ra_hir/src/diagnostics.rs b/crates/ra_hir/src/diagnostics.rs
new file mode 100644
index 000000000..d6a51b833
--- /dev/null
+++ b/crates/ra_hir/src/diagnostics.rs
@@ -0,0 +1,115 @@
+use std::{fmt, any::Any};
+
+use ra_syntax::{SyntaxNodePtr, TreeArc, AstPtr, TextRange, ast, SyntaxNode};
+use relative_path::RelativePathBuf;
+
+use crate::{HirFileId, HirDatabase};
+
+/// Diagnostic defines hir API for errors and warnings.
+///
+/// It is used as a `dyn` object, which you can downcast to a concrete
+/// diagnostic. DiagnosticSink are structured, meaning that they include rich
+/// information which can be used by IDE to create fixes. DiagnosticSink are
+/// expressed in terms of macro-expanded syntax tree nodes (so, it's a bad idea
+/// to diagnostic in a salsa value).
+///
+/// Internally, various subsystems of hir produce diagnostics specific to a
+/// subsystem (typically, an `enum`), which are safe to store in salsa but do not
+/// include source locations. Such internal diagnostic are transformed into an
+/// instance of `Diagnostic` on demand.
+pub trait Diagnostic: Any + Send + Sync + fmt::Debug + 'static {
+    fn message(&self) -> String;
+    fn file(&self) -> HirFileId;
+    fn syntax_node_ptr(&self) -> SyntaxNodePtr;
+    fn highlight_range(&self) -> TextRange {
+        self.syntax_node_ptr().range()
+    }
+    fn as_any(&self) -> &(dyn Any + Send + 'static);
+}
+
+impl dyn Diagnostic {
+    pub fn syntax_node(&self, db: &impl HirDatabase) -> TreeArc<SyntaxNode> {
+        let source_file = db.hir_parse(self.file());
+        self.syntax_node_ptr().to_node(&source_file).to_owned()
+    }
+    pub fn downcast_ref<D: Diagnostic>(&self) -> Option<&D> {
+        self.as_any().downcast_ref()
+    }
+}
+
+pub struct DiagnosticSink<'a> {
+    callbacks: Vec<Box<dyn FnMut(&dyn Diagnostic) -> Result<(), ()> + 'a>>,
+    default_callback: Box<dyn FnMut(&dyn Diagnostic) + 'a>,
+}
+
+impl<'a> DiagnosticSink<'a> {
+    pub fn new(cb: impl FnMut(&dyn Diagnostic) + 'a) -> DiagnosticSink<'a> {
+        DiagnosticSink { callbacks: Vec::new(), default_callback: Box::new(cb) }
+    }
+
+    pub fn on<D: Diagnostic, F: FnMut(&D) + 'a>(mut self, mut cb: F) -> DiagnosticSink<'a> {
+        let cb = move |diag: &dyn Diagnostic| match diag.downcast_ref::<D>() {
+            Some(d) => {
+                cb(d);
+                Ok(())
+            }
+            None => Err(()),
+        };
+        self.callbacks.push(Box::new(cb));
+        self
+    }
+
+    pub(crate) fn push(&mut self, d: impl Diagnostic) {
+        let d: &dyn Diagnostic = &d;
+        for cb in self.callbacks.iter_mut() {
+            match cb(d) {
+                Ok(()) => return,
+                Err(()) => (),
+            }
+        }
+        (self.default_callback)(d)
+    }
+}
+
+#[derive(Debug)]
+pub struct NoSuchField {
+    pub file: HirFileId,
+    pub field: AstPtr<ast::NamedField>,
+}
+
+impl Diagnostic for NoSuchField {
+    fn message(&self) -> String {
+        "no such field".to_string()
+    }
+    fn file(&self) -> HirFileId {
+        self.file
+    }
+    fn syntax_node_ptr(&self) -> SyntaxNodePtr {
+        self.field.into()
+    }
+    fn as_any(&self) -> &(Any + Send + 'static) {
+        self
+    }
+}
+
+#[derive(Debug)]
+pub struct UnresolvedModule {
+    pub file: HirFileId,
+    pub decl: AstPtr<ast::Module>,
+    pub candidate: RelativePathBuf,
+}
+
+impl Diagnostic for UnresolvedModule {
+    fn message(&self) -> String {
+        "unresolved module".to_string()
+    }
+    fn file(&self) -> HirFileId {
+        self.file
+    }
+    fn syntax_node_ptr(&self) -> SyntaxNodePtr {
+        self.decl.into()
+    }
+    fn as_any(&self) -> &(Any + Send + 'static) {
+        self
+    }
+}
diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs
index 703d99d9b..a85422955 100644
--- a/crates/ra_hir/src/expr.rs
+++ b/crates/ra_hir/src/expr.rs
@@ -5,7 +5,7 @@ use rustc_hash::FxHashMap;
 
 use ra_arena::{Arena, RawId, impl_arena_id, map::ArenaMap};
 use ra_syntax::{
-    SyntaxNodePtr, AstNode,
+    SyntaxNodePtr, AstPtr, AstNode,
     ast::{self, LoopBodyOwner, ArgListOwner, NameOwner, LiteralFlavor, TypeAscriptionOwner}
 };
 
@@ -54,6 +54,7 @@ pub struct BodySourceMap {
     expr_map_back: ArenaMap<ExprId, SyntaxNodePtr>,
     pat_map: FxHashMap<SyntaxNodePtr, PatId>,
     pat_map_back: ArenaMap<PatId, SyntaxNodePtr>,
+    field_map: FxHashMap<(ExprId, usize), AstPtr<ast::NamedField>>,
 }
 
 impl Body {
@@ -138,6 +139,10 @@ impl BodySourceMap {
     pub fn node_pat(&self, node: &ast::Pat) -> Option<PatId> {
         self.pat_map.get(&SyntaxNodePtr::new(node.syntax())).cloned()
     }
+
+    pub fn field_syntax(&self, expr: ExprId, field: usize) -> AstPtr<ast::NamedField> {
+        self.field_map[&(expr, field)].clone()
+    }
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
@@ -629,8 +634,10 @@ impl ExprCollector {
             }
             ast::ExprKind::StructLit(e) => {
                 let path = e.path().and_then(Path::from_ast);
+                let mut field_ptrs = Vec::new();
                 let fields = if let Some(nfl) = e.named_field_list() {
                     nfl.fields()
+                        .inspect(|field| field_ptrs.push(AstPtr::new(*field)))
                         .map(|field| StructLitField {
                             name: field
                                 .name_ref()
@@ -657,7 +664,11 @@ impl ExprCollector {
                     Vec::new()
                 };
                 let spread = e.spread().map(|s| self.collect_expr(s));
-                self.alloc_expr(Expr::StructLit { path, fields, spread }, syntax_ptr)
+                let res = self.alloc_expr(Expr::StructLit { path, fields, spread }, syntax_ptr);
+                for (i, ptr) in field_ptrs.into_iter().enumerate() {
+                    self.source_map.field_map.insert((res, i), ptr);
+                }
+                res
             }
             ast::ExprKind::FieldExpr(e) => {
                 let expr = self.collect_expr_opt(e.expr());
@@ -680,7 +691,7 @@ impl ExprCollector {
             }
             ast::ExprKind::PrefixExpr(e) => {
                 let expr = self.collect_expr_opt(e.expr());
-                if let Some(op) = e.op() {
+                if let Some(op) = e.op_kind() {
                     self.alloc_expr(Expr::UnaryOp { expr, op }, syntax_ptr)
                 } else {
                     self.alloc_expr(Expr::Missing, syntax_ptr)
@@ -703,7 +714,7 @@ impl ExprCollector {
             ast::ExprKind::BinExpr(e) => {
                 let lhs = self.collect_expr_opt(e.lhs());
                 let rhs = self.collect_expr_opt(e.rhs());
-                let op = e.op();
+                let op = e.op_kind();
                 self.alloc_expr(Expr::BinaryOp { lhs, rhs, op }, syntax_ptr)
             }
             ast::ExprKind::TupleExpr(e) => {
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index a89c916f8..ce54d7608 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -35,6 +35,7 @@ mod expr;
 mod generics;
 mod docs;
 mod resolve;
+pub mod diagnostics;
 
 mod code_model_api;
 mod code_model_impl;
@@ -63,7 +64,7 @@ pub use self::{
 
 pub use self::code_model_api::{
     Crate, CrateDependency,
-    Module, ModuleDef, ModuleSource, Problem,
+    Module, ModuleDef, ModuleSource,
     Struct, Enum, EnumVariant,
     Function, FnSignature,
     StructField, FieldSource,
diff --git a/crates/ra_hir/src/mock.rs b/crates/ra_hir/src/mock.rs
index 10d4c1b8c..aeab6b180 100644
--- a/crates/ra_hir/src/mock.rs
+++ b/crates/ra_hir/src/mock.rs
@@ -9,7 +9,7 @@ use relative_path::RelativePathBuf;
 use test_utils::{parse_fixture, CURSOR_MARKER, extract_offset};
 use rustc_hash::FxHashMap;
 
-use crate::{db, HirInterner};
+use crate::{db, HirInterner, diagnostics::DiagnosticSink};
 
 pub const WORKSPACE: SourceRootId = SourceRootId(0);
 
@@ -70,6 +70,22 @@ impl MockDatabase {
         self.set_crate_graph(Arc::new(crate_graph))
     }
 
+    pub fn diagnostics(&self) -> String {
+        let mut buf = String::from("\n");
+        let mut files: Vec<FileId> = self.files.values().map(|&it| it).collect();
+        files.sort();
+        for file in files {
+            let module = crate::source_binder::module_from_file_id(self, file).unwrap();
+            module.diagnostics(
+                self,
+                &mut DiagnosticSink::new(|d| {
+                    buf += &format!("{:?}: {}\n", d.syntax_node(self).text(), d.message());
+                }),
+            )
+        }
+        buf
+    }
+
     fn from_fixture(fixture: &str) -> (MockDatabase, Option<FilePosition>) {
         let mut db = MockDatabase::default();
 
diff --git a/crates/ra_hir/src/nameres.rs b/crates/ra_hir/src/nameres.rs
index d361cf9e6..56ed872d5 100644
--- a/crates/ra_hir/src/nameres.rs
+++ b/crates/ra_hir/src/nameres.rs
@@ -61,9 +61,11 @@ use ra_db::{FileId, Edition};
 use test_utils::tested_by;
 
 use crate::{
-    ModuleDef, Name, Crate, Module, Problem,
+    ModuleDef, Name, Crate, Module,
     DefDatabase, Path, PathKind, HirFileId,
     ids::{SourceItemId, SourceFileItemId, MacroCallId},
+    diagnostics::DiagnosticSink,
+    nameres::diagnostics::DefDiagnostic,
 };
 
 pub(crate) use self::raw::{RawItems, ImportId, ImportSourceMap};
@@ -85,7 +87,7 @@ pub struct CrateDefMap {
     macros: Arena<CrateMacroId, mbe::MacroRules>,
     public_macros: FxHashMap<Name, CrateMacroId>,
     macro_resolutions: FxHashMap<MacroCallId, (Crate, CrateMacroId)>,
-    problems: CrateDefMapProblems,
+    diagnostics: Vec<DefDiagnostic>,
 }
 
 impl std::ops::Index<CrateModuleId> for CrateDefMap {
@@ -125,21 +127,6 @@ pub(crate) struct ModuleData {
     pub(crate) definition: Option<FileId>,
 }
 
-#[derive(Default, Debug, PartialEq, Eq)]
-pub(crate) struct CrateDefMapProblems {
-    problems: Vec<(SourceItemId, Problem)>,
-}
-
-impl CrateDefMapProblems {
-    fn add(&mut self, source_item_id: SourceItemId, problem: Problem) {
-        self.problems.push((source_item_id, problem))
-    }
-
-    pub(crate) fn iter<'a>(&'a self) -> impl Iterator<Item = (&'a SourceItemId, &'a Problem)> + 'a {
-        self.problems.iter().map(|(s, p)| (s, p))
-    }
-}
-
 #[derive(Debug, Default, PartialEq, Eq, Clone)]
 pub struct ModuleScope {
     items: FxHashMap<Name, Resolution>,
@@ -212,7 +199,7 @@ impl CrateDefMap {
                 macros: Arena::default(),
                 public_macros: FxHashMap::default(),
                 macro_resolutions: FxHashMap::default(),
-                problems: CrateDefMapProblems::default(),
+                diagnostics: Vec::new(),
             }
         };
         let def_map = collector::collect_defs(db, def_map);
@@ -224,10 +211,6 @@ impl CrateDefMap {
         self.root
     }
 
-    pub(crate) fn problems(&self) -> &CrateDefMapProblems {
-        &self.problems
-    }
-
     pub(crate) fn mk_module(&self, module_id: CrateModuleId) -> Module {
         Module { krate: self.krate, module_id }
     }
@@ -240,6 +223,15 @@ impl CrateDefMap {
         &self.extern_prelude
     }
 
+    pub(crate) fn add_diagnostics(
+        &self,
+        db: &impl DefDatabase,
+        module: CrateModuleId,
+        sink: &mut DiagnosticSink,
+    ) {
+        self.diagnostics.iter().for_each(|it| it.add_to(db, module, sink))
+    }
+
     pub(crate) fn resolve_macro(
         &self,
         macro_call_id: MacroCallId,
@@ -452,3 +444,48 @@ impl CrateDefMap {
         }
     }
 }
+
+mod diagnostics {
+    use relative_path::RelativePathBuf;
+    use ra_syntax::{AstPtr, AstNode, ast};
+
+    use crate::{
+        SourceItemId, DefDatabase,
+        nameres::CrateModuleId,
+        diagnostics::{DiagnosticSink, UnresolvedModule},
+};
+
+    #[derive(Debug, PartialEq, Eq)]
+    pub(super) enum DefDiagnostic {
+        UnresolvedModule {
+            module: CrateModuleId,
+            declaration: SourceItemId,
+            candidate: RelativePathBuf,
+        },
+    }
+
+    impl DefDiagnostic {
+        pub(super) fn add_to(
+            &self,
+            db: &impl DefDatabase,
+            target_module: CrateModuleId,
+            sink: &mut DiagnosticSink,
+        ) {
+            match self {
+                DefDiagnostic::UnresolvedModule { module, declaration, candidate } => {
+                    if *module != target_module {
+                        return;
+                    }
+                    let syntax = db.file_item(*declaration);
+                    let decl = ast::Module::cast(&syntax).unwrap();
+                    sink.push(UnresolvedModule {
+                        file: declaration.file_id,
+                        decl: AstPtr::new(&decl),
+                        candidate: candidate.clone(),
+                    })
+                }
+            }
+        }
+    }
+
+}
diff --git a/crates/ra_hir/src/nameres/collector.rs b/crates/ra_hir/src/nameres/collector.rs
index c5b73cfbe..8830b4624 100644
--- a/crates/ra_hir/src/nameres/collector.rs
+++ b/crates/ra_hir/src/nameres/collector.rs
@@ -6,14 +6,17 @@ use ra_db::FileId;
 
 use crate::{
     Function, Module, Struct, Enum, Const, Static, Trait, TypeAlias,
-    DefDatabase, HirFileId, Name, Path, Problem, Crate,
+    DefDatabase, HirFileId, Name, Path, Crate,
     KnownName,
-    nameres::{Resolution, PerNs, ModuleDef, ReachedFixedPoint, ResolveMode, raw},
+    nameres::{
+        Resolution, PerNs, ModuleDef, ReachedFixedPoint, ResolveMode,
+        CrateDefMap, CrateModuleId, ModuleData, CrateMacroId,
+        diagnostics::DefDiagnostic,
+        raw,
+    },
     ids::{AstItemDef, LocationCtx, MacroCallLoc, SourceItemId, MacroCallId},
 };
 
-use super::{CrateDefMap, CrateModuleId, ModuleData, CrateMacroId};
-
 pub(super) fn collect_defs(db: &impl DefDatabase, mut def_map: CrateDefMap) -> CrateDefMap {
     // populate external prelude
     for dep in def_map.krate.dependencies(db) {
@@ -405,25 +408,27 @@ where
             raw::ModuleData::Declaration { name, source_item_id } => {
                 let source_item_id = source_item_id.with_file_id(self.file_id);
                 let is_root = self.def_collector.def_map.modules[self.module_id].parent.is_none();
-                let (file_ids, problem) =
-                    resolve_submodule(self.def_collector.db, self.file_id, name, is_root);
-
-                if let Some(problem) = problem {
-                    self.def_collector.def_map.problems.add(source_item_id, problem)
-                }
-
-                if let Some(&file_id) = file_ids.first() {
-                    let module_id =
-                        self.push_child_module(name.clone(), source_item_id, Some(file_id));
-                    let raw_items = self.def_collector.db.raw_items(file_id);
-                    ModCollector {
-                        def_collector: &mut *self.def_collector,
-                        module_id,
-                        file_id: file_id.into(),
-                        raw_items: &raw_items,
+                match resolve_submodule(self.def_collector.db, self.file_id, name, is_root) {
+                    Ok(file_id) => {
+                        let module_id =
+                            self.push_child_module(name.clone(), source_item_id, Some(file_id));
+                        let raw_items = self.def_collector.db.raw_items(file_id);
+                        ModCollector {
+                            def_collector: &mut *self.def_collector,
+                            module_id,
+                            file_id: file_id.into(),
+                            raw_items: &raw_items,
+                        }
+                        .collect(raw_items.items())
                     }
-                    .collect(raw_items.items())
-                }
+                    Err(candidate) => self.def_collector.def_map.diagnostics.push(
+                        DefDiagnostic::UnresolvedModule {
+                            module: self.module_id,
+                            declaration: source_item_id,
+                            candidate,
+                        },
+                    ),
+                };
             }
         }
     }
@@ -524,7 +529,7 @@ fn resolve_submodule(
     file_id: HirFileId,
     name: &Name,
     is_root: bool,
-) -> (Vec<FileId>, Option<Problem>) {
+) -> Result<FileId, RelativePathBuf> {
     // FIXME: handle submodules of inline modules properly
     let file_id = file_id.original_file(db);
     let source_root_id = db.file_source_root(file_id);
@@ -545,17 +550,10 @@ fn resolve_submodule(
         candidates.push(file_dir_mod.clone());
     };
     let sr = db.source_root(source_root_id);
-    let points_to = candidates
-        .into_iter()
-        .filter_map(|path| sr.files.get(&path))
-        .map(|&it| it)
-        .collect::<Vec<_>>();
-    let problem = if points_to.is_empty() {
-        Some(Problem::UnresolvedModule {
-            candidate: if is_dir_owner { file_mod } else { file_dir_mod },
-        })
-    } else {
-        None
-    };
-    (points_to, problem)
+    let mut points_to = candidates.into_iter().filter_map(|path| sr.files.get(&path)).map(|&it| it);
+    // FIXME: handle ambiguity
+    match points_to.next() {
+        Some(file_id) => Ok(file_id),
+        None => Err(if is_dir_owner { file_mod } else { file_dir_mod }),
+    }
 }
diff --git a/crates/ra_hir/src/nameres/tests.rs b/crates/ra_hir/src/nameres/tests.rs
index ac9b88520..572bd1bf7 100644
--- a/crates/ra_hir/src/nameres/tests.rs
+++ b/crates/ra_hir/src/nameres/tests.rs
@@ -552,3 +552,22 @@ foo: v
 "###
     );
 }
+
+#[test]
+fn unresolved_module_diagnostics() {
+    let diagnostics = MockDatabase::with_files(
+        r"
+        //- /lib.rs
+        mod foo;
+        mod bar;
+        mod baz {}
+        //- /foo.rs
+        ",
+    )
+    .diagnostics();
+
+    assert_snapshot_matches!(diagnostics, @r###"
+"mod bar;": unresolved module
+"###
+    );
+}
diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index cff7e7481..5fd602a9e 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -36,7 +36,9 @@ use crate::{
     path::{GenericArgs, GenericArg},
     adt::VariantDef,
     resolve::{Resolver, Resolution},
-    nameres::Namespace
+    nameres::Namespace,
+    ty::infer::diagnostics::InferenceDiagnostic,
+    diagnostics::DiagnosticSink,
 };
 use super::{Ty, TypableDef, Substs, primitive, op, FnSig, ApplicationTy, TypeCtor};
 
@@ -96,6 +98,7 @@ pub struct InferenceResult {
     field_resolutions: FxHashMap<ExprId, StructField>,
     /// For each associated item record what it resolves to
     assoc_resolutions: FxHashMap<ExprOrPatId, ImplItem>,
+    diagnostics: Vec<InferenceDiagnostic>,
     pub(super) type_of_expr: ArenaMap<ExprId, Ty>,
     pub(super) type_of_pat: ArenaMap<PatId, Ty>,
 }
@@ -113,6 +116,14 @@ impl InferenceResult {
     pub fn assoc_resolutions_for_pat(&self, id: PatId) -> Option<ImplItem> {
         self.assoc_resolutions.get(&id.into()).map(|it| *it)
     }
+    pub(crate) fn add_diagnostics(
+        &self,
+        db: &impl HirDatabase,
+        owner: Function,
+        sink: &mut DiagnosticSink,
+    ) {
+        self.diagnostics.iter().for_each(|it| it.add_to(db, owner, sink))
+    }
 }
 
 impl Index<ExprId> for InferenceResult {
@@ -143,6 +154,7 @@ struct InferenceContext<'a, D: HirDatabase> {
     assoc_resolutions: FxHashMap<ExprOrPatId, ImplItem>,
     type_of_expr: ArenaMap<ExprId, Ty>,
     type_of_pat: ArenaMap<PatId, Ty>,
+    diagnostics: Vec<InferenceDiagnostic>,
     /// The return type of the function being inferred.
     return_ty: Ty,
 }
@@ -155,6 +167,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             assoc_resolutions: FxHashMap::default(),
             type_of_expr: ArenaMap::default(),
             type_of_pat: ArenaMap::default(),
+            diagnostics: Vec::default(),
             var_unification_table: InPlaceUnificationTable::new(),
             return_ty: Ty::Unknown, // set in collect_fn_signature
             db,
@@ -181,6 +194,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             assoc_resolutions: self.assoc_resolutions,
             type_of_expr: expr_types,
             type_of_pat: pat_types,
+            diagnostics: self.diagnostics,
         }
     }
 
@@ -915,9 +929,18 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             Expr::StructLit { path, fields, spread } => {
                 let (ty, def_id) = self.resolve_variant(path.as_ref());
                 let substs = ty.substs().unwrap_or_else(Substs::empty);
-                for field in fields {
+                for (field_idx, field) in fields.into_iter().enumerate() {
                     let field_ty = def_id
-                        .and_then(|it| it.field(self.db, &field.name))
+                        .and_then(|it| match it.field(self.db, &field.name) {
+                            Some(field) => Some(field),
+                            None => {
+                                self.diagnostics.push(InferenceDiagnostic::NoSuchField {
+                                    expr: tgt_expr,
+                                    field: field_idx,
+                                });
+                                None
+                            }
+                        })
                         .map_or(Ty::Unknown, |field| field.ty(self.db))
                         .subst(&substs);
                     self.infer_expr(field.expr, &Expectation::has_type(field_ty));
@@ -1244,3 +1267,29 @@ impl Expectation {
         Expectation { ty: Ty::Unknown }
     }
 }
+
+mod diagnostics {
+    use crate::{expr::ExprId, diagnostics::{DiagnosticSink, NoSuchField}, HirDatabase, Function};
+
+    #[derive(Debug, PartialEq, Eq, Clone)]
+    pub(super) enum InferenceDiagnostic {
+        NoSuchField { expr: ExprId, field: usize },
+    }
+
+    impl InferenceDiagnostic {
+        pub(super) fn add_to(
+            &self,
+            db: &impl HirDatabase,
+            owner: Function,
+            sink: &mut DiagnosticSink,
+        ) {
+            match self {
+                InferenceDiagnostic::NoSuchField { expr, field } => {
+                    let (file, _) = owner.source(db);
+                    let field = owner.body_source_map(db).field_syntax(*expr, *field);
+                    sink.push(NoSuchField { file, field })
+                }
+            }
+        }
+    }
+}
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index 5d8ad4aa7..3aedba243 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -2319,3 +2319,27 @@ fn typing_whitespace_inside_a_function_should_not_invalidate_types() {
         assert!(!format!("{:?}", events).contains("infer"), "{:#?}", events)
     }
 }
+
+#[test]
+fn no_such_field_diagnostics() {
+    let diagnostics = MockDatabase::with_files(
+        r"
+        //- /lib.rs
+        struct S { foo: i32, bar: () }
+        impl S {
+            fn new() -> S {
+                S {
+                    foo: 92,
+                    baz: 62,
+                }
+            }
+        }
+        ",
+    )
+    .diagnostics();
+
+    assert_snapshot_matches!(diagnostics, @r###"
+"baz: 62": no such field
+"###
+    );
+}
diff --git a/crates/ra_ide_api/Cargo.toml b/crates/ra_ide_api/Cargo.toml
index c64226801..45bab4e28 100644
--- a/crates/ra_ide_api/Cargo.toml
+++ b/crates/ra_ide_api/Cargo.toml
@@ -20,7 +20,6 @@ jemallocator = { version = "0.1.9", optional = true }
 jemalloc-ctl = { version = "0.2.0", optional = true }
 
 ra_syntax = { path = "../ra_syntax" }
-ra_ide_api_light = { path = "../ra_ide_api_light" }
 ra_text_edit = { path = "../ra_text_edit" }
 ra_db = { path = "../ra_db" }
 ra_fmt = { path = "../ra_fmt" }
diff --git a/crates/ra_ide_api/src/assists.rs b/crates/ra_ide_api/src/assists.rs
index 3c0475a51..355c0a42a 100644
--- a/crates/ra_ide_api/src/assists.rs
+++ b/crates/ra_ide_api/src/assists.rs
@@ -17,14 +17,9 @@ pub(crate) fn assists(db: &RootDatabase, frange: FileRange) -> Vec<Assist> {
             let file_id = frange.file_id;
             let file_edit = SourceFileEdit { file_id, edit: action.edit };
             let id = label.id;
-            let change = SourceChange {
-                label: label.label,
-                source_file_edits: vec![file_edit],
-                file_system_edits: vec![],
-                cursor_position: action
-                    .cursor_position
-                    .map(|offset| FilePosition { offset, file_id }),
-            };
+            let change = SourceChange::source_file_edit(label.label, file_edit).with_cursor_opt(
+                action.cursor_position.map(|offset| FilePosition { offset, file_id }),
+            );
             Assist { id, change }
         })
         .collect()
diff --git a/crates/ra_ide_api/src/diagnostics.rs b/crates/ra_ide_api/src/diagnostics.rs
index b9dc424c6..5a78e94d8 100644
--- a/crates/ra_ide_api/src/diagnostics.rs
+++ b/crates/ra_ide_api/src/diagnostics.rs
@@ -1,10 +1,11 @@
+use std::cell::RefCell;
+
 use itertools::Itertools;
-use hir::{Problem, source_binder};
+use hir::{source_binder, diagnostics::{Diagnostic as _, DiagnosticSink}};
 use ra_db::SourceDatabase;
 use ra_syntax::{
     Location, SourceFile, SyntaxKind, TextRange, SyntaxNode,
     ast::{self, AstNode},
-
 };
 use ra_text_edit::{TextEdit, TextEditBuilder};
 
@@ -26,11 +27,31 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
         check_unnecessary_braces_in_use_statement(&mut res, file_id, node);
         check_struct_shorthand_initialization(&mut res, file_id, node);
     }
-
+    let res = RefCell::new(res);
+    let mut sink = DiagnosticSink::new(|d| {
+        res.borrow_mut().push(Diagnostic {
+            message: d.message(),
+            range: d.highlight_range(),
+            severity: Severity::Error,
+            fix: None,
+        })
+    })
+    .on::<hir::diagnostics::UnresolvedModule, _>(|d| {
+        let source_root = db.file_source_root(d.file().original_file(db));
+        let create_file = FileSystemEdit::CreateFile { source_root, path: d.candidate.clone() };
+        let fix = SourceChange::file_system_edit("create module", create_file);
+        res.borrow_mut().push(Diagnostic {
+            range: d.highlight_range(),
+            message: d.message(),
+            severity: Severity::Error,
+            fix: Some(fix),
+        })
+    });
     if let Some(m) = source_binder::module_from_file_id(db, file_id) {
-        check_module(&mut res, db, file_id, m);
+        m.diagnostics(db, &mut sink);
     };
-    res
+    drop(sink);
+    res.into_inner()
 }
 
 fn syntax_errors(acc: &mut Vec<Diagnostic>, source_file: &SourceFile) {
@@ -71,12 +92,10 @@ fn check_unnecessary_braces_in_use_statement(
             range,
             message: format!("Unnecessary braces in use statement"),
             severity: Severity::WeakWarning,
-            fix: Some(SourceChange {
-                label: "Remove unnecessary braces".to_string(),
-                source_file_edits: vec![SourceFileEdit { file_id, edit }],
-                file_system_edits: Vec::new(),
-                cursor_position: None,
-            }),
+            fix: Some(SourceChange::source_file_edit(
+                "Remove unnecessary braces",
+                SourceFileEdit { file_id, edit },
+            )),
         });
     }
 
@@ -119,12 +138,10 @@ fn check_struct_shorthand_initialization(
                     range: named_field.syntax().range(),
                     message: format!("Shorthand struct initialization"),
                     severity: Severity::WeakWarning,
-                    fix: Some(SourceChange {
-                        label: "use struct shorthand initialization".to_string(),
-                        source_file_edits: vec![SourceFileEdit { file_id, edit }],
-                        file_system_edits: Vec::new(),
-                        cursor_position: None,
-                    }),
+                    fix: Some(SourceChange::source_file_edit(
+                        "use struct shorthand initialization",
+                        SourceFileEdit { file_id, edit },
+                    )),
                 });
             }
         }
@@ -132,39 +149,12 @@ fn check_struct_shorthand_initialization(
     Some(())
 }
 
-fn check_module(
-    acc: &mut Vec<Diagnostic>,
-    db: &RootDatabase,
-    file_id: FileId,
-    module: hir::Module,
-) {
-    let source_root = db.file_source_root(file_id);
-    for (name_node, problem) in module.problems(db) {
-        let diag = match problem {
-            Problem::UnresolvedModule { candidate } => {
-                let create_file =
-                    FileSystemEdit::CreateFile { source_root, path: candidate.clone() };
-                let fix = SourceChange {
-                    label: "create module".to_string(),
-                    source_file_edits: Vec::new(),
-                    file_system_edits: vec![create_file],
-                    cursor_position: None,
-                };
-                Diagnostic {
-                    range: name_node.range(),
-                    message: "unresolved module".to_string(),
-                    severity: Severity::Error,
-                    fix: Some(fix),
-                }
-            }
-        };
-        acc.push(diag)
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use test_utils::assert_eq_text;
+    use insta::assert_debug_snapshot_matches;
+
+    use crate::mock_analysis::single_file;
 
     use super::*;
 
@@ -194,6 +184,34 @@ mod tests {
     }
 
     #[test]
+    fn test_unresolved_module_diagnostic() {
+        let (analysis, file_id) = single_file("mod foo;");
+        let diagnostics = analysis.diagnostics(file_id).unwrap();
+        assert_debug_snapshot_matches!(diagnostics, @r####"[
+    Diagnostic {
+        message: "unresolved module",
+        range: [0; 8),
+        fix: Some(
+            SourceChange {
+                label: "create module",
+                source_file_edits: [],
+                file_system_edits: [
+                    CreateFile {
+                        source_root: SourceRootId(
+                            0
+                        ),
+                        path: "foo.rs"
+                    }
+                ],
+                cursor_position: None
+            }
+        ),
+        severity: Error
+    }
+]"####);
+    }
+
+    #[test]
     fn test_check_unnecessary_braces_in_use_statement() {
         check_not_applicable(
             "
diff --git a/crates/ra_ide_api/src/lib.rs b/crates/ra_ide_api/src/lib.rs
index 99f18b6b8..9063f78a9 100644
--- a/crates/ra_ide_api/src/lib.rs
+++ b/crates/ra_ide_api/src/lib.rs
@@ -6,9 +6,6 @@
 //! database, and the `ra_hir` crate, where majority of the analysis happens.
 //! However, IDE specific bits of the analysis (most notably completion) happen
 //! in this crate.
-//!
-//! The sibling `ra_ide_api_light` handles those bits of IDE functionality
-//! which are restricted to a single file and need only syntax.
 
 // For proving that RootDatabase is RefUnwindSafe.
 #![recursion_limit = "128"]
@@ -33,10 +30,11 @@ mod impls;
 mod assists;
 mod diagnostics;
 mod syntax_tree;
-mod line_index;
 mod folding_ranges;
+mod line_index;
 mod line_index_utils;
 mod join_lines;
+mod structure;
 mod typing;
 mod matching_brace;
 
@@ -72,9 +70,10 @@ pub use crate::{
     line_index_utils::translate_offset_with_edit,
     folding_ranges::{Fold, FoldKind},
     syntax_highlighting::HighlightedRange,
+    structure::{StructureNode, file_structure},
     diagnostics::Severity,
 };
-pub use ra_ide_api_light::StructureNode;
+
 pub use ra_db::{
     Canceled, CrateGraph, CrateId, FileId, FilePosition, FileRange, SourceRootId,
     Edition
@@ -97,6 +96,79 @@ pub struct SourceChange {
     pub cursor_position: Option<FilePosition>,
 }
 
+impl SourceChange {
+    /// Creates a new SourceChange with the given label
+    /// from the edits.
+    pub(crate) fn from_edits<L: Into<String>>(
+        label: L,
+        source_file_edits: Vec<SourceFileEdit>,
+        file_system_edits: Vec<FileSystemEdit>,
+    ) -> Self {
+        SourceChange {
+            label: label.into(),
+            source_file_edits,
+            file_system_edits,
+            cursor_position: None,
+        }
+    }
+
+    /// Creates a new SourceChange with the given label,
+    /// containing only the given `SourceFileEdits`.
+    pub(crate) fn source_file_edits<L: Into<String>>(label: L, edits: Vec<SourceFileEdit>) -> Self {
+        SourceChange {
+            label: label.into(),
+            source_file_edits: edits,
+            file_system_edits: vec![],
+            cursor_position: None,
+        }
+    }
+
+    /// Creates a new SourceChange with the given label,
+    /// containing only the given `FileSystemEdits`.
+    pub(crate) fn file_system_edits<L: Into<String>>(label: L, edits: Vec<FileSystemEdit>) -> Self {
+        SourceChange {
+            label: label.into(),
+            source_file_edits: vec![],
+            file_system_edits: edits,
+            cursor_position: None,
+        }
+    }
+
+    /// Creates a new SourceChange with the given label,
+    /// containing only a single `SourceFileEdit`.
+    pub(crate) fn source_file_edit<L: Into<String>>(label: L, edit: SourceFileEdit) -> Self {
+        SourceChange::source_file_edits(label, vec![edit])
+    }
+
+    /// Creates a new SourceChange with the given label
+    /// from the given `FileId` and `TextEdit`
+    pub(crate) fn source_file_edit_from<L: Into<String>>(
+        label: L,
+        file_id: FileId,
+        edit: TextEdit,
+    ) -> Self {
+        SourceChange::source_file_edit(label, SourceFileEdit { file_id, edit })
+    }
+
+    /// Creates a new SourceChange with the given label
+    /// from the given `FileId` and `TextEdit`
+    pub(crate) fn file_system_edit<L: Into<String>>(label: L, edit: FileSystemEdit) -> Self {
+        SourceChange::file_system_edits(label, vec![edit])
+    }
+
+    /// Sets the cursor position to the given `FilePosition`
+    pub(crate) fn with_cursor(mut self, cursor_position: FilePosition) -> Self {
+        self.cursor_position = Some(cursor_position);
+        self
+    }
+
+    /// Sets the cursor position to the given `FilePosition`
+    pub(crate) fn with_cursor_opt(mut self, cursor_position: Option<FilePosition>) -> Self {
+        self.cursor_position = cursor_position;
+        self
+    }
+}
+
 #[derive(Debug)]
 pub struct SourceFileEdit {
     pub file_id: FileId,
@@ -285,12 +357,7 @@ impl Analysis {
             file_id: frange.file_id,
             edit: join_lines::join_lines(&file, frange.range),
         };
-        SourceChange {
-            label: "join lines".to_string(),
-            source_file_edits: vec![file_edit],
-            file_system_edits: vec![],
-            cursor_position: None,
-        }
+        SourceChange::source_file_edit("join lines", file_edit)
     }
 
     /// Returns an edit which should be applied when opening a new line, fixing
@@ -305,12 +372,10 @@ impl Analysis {
     pub fn on_eq_typed(&self, position: FilePosition) -> Option<SourceChange> {
         let file = self.db.parse(position.file_id);
         let edit = typing::on_eq_typed(&file, position.offset)?;
-        Some(SourceChange {
-            label: "add semicolon".to_string(),
-            source_file_edits: vec![SourceFileEdit { edit, file_id: position.file_id }],
-            file_system_edits: vec![],
-            cursor_position: None,
-        })
+        Some(SourceChange::source_file_edit(
+            "add semicolon",
+            SourceFileEdit { edit, file_id: position.file_id },
+        ))
     }
 
     /// Returns an edit which should be applied when a dot ('.') is typed on a blank line, indenting the line appropriately.
@@ -322,7 +387,7 @@ impl Analysis {
     /// file outline.
     pub fn file_structure(&self, file_id: FileId) -> Vec<StructureNode> {
         let file = self.db.parse(file_id);
-        ra_ide_api_light::file_structure(&file)
+        structure::file_structure(&file)
     }
 
     /// Returns the set of folding ranges.
diff --git a/crates/ra_ide_api/src/references.rs b/crates/ra_ide_api/src/references.rs
index b7784e577..22741445a 100644
--- a/crates/ra_ide_api/src/references.rs
+++ b/crates/ra_ide_api/src/references.rs
@@ -187,12 +187,7 @@ fn rename_mod(
     };
     source_file_edits.push(edit);
 
-    Some(SourceChange {
-        label: "rename".to_string(),
-        source_file_edits,
-        file_system_edits,
-        cursor_position: None,
-    })
+    Some(SourceChange::from_edits("rename", source_file_edits, file_system_edits))
 }
 
 fn rename_reference(
@@ -211,12 +206,7 @@ fn rename_reference(
         return None;
     }
 
-    Some(SourceChange {
-        label: "rename".to_string(),
-        source_file_edits: edit,
-        file_system_edits: Vec::new(),
-        cursor_position: None,
-    })
+    Some(SourceChange::source_file_edits("rename", edit))
 }
 
 #[cfg(test)]
diff --git a/crates/ra_ide_api_light/src/snapshots/tests__file_structure.snap b/crates/ra_ide_api/src/snapshots/tests__file_structure.snap
index 8e4184b31..2efa8e22c 100644
--- a/crates/ra_ide_api_light/src/snapshots/tests__file_structure.snap
+++ b/crates/ra_ide_api/src/snapshots/tests__file_structure.snap
@@ -1,7 +1,7 @@
 ---
 created: "2019-02-05T22:03:50.763530100Z"
 creator: [email protected]
-source: crates/ra_ide_api_light/src/structure.rs
+source: crates/ra_ide_api/src/structure.rs
 expression: structure
 ---
 [
diff --git a/crates/ra_ide_api_light/src/structure.rs b/crates/ra_ide_api/src/structure.rs
index ec2c9bbc6..ec2c9bbc6 100644
--- a/crates/ra_ide_api_light/src/structure.rs
+++ b/crates/ra_ide_api/src/structure.rs
diff --git a/crates/ra_ide_api/src/typing.rs b/crates/ra_ide_api/src/typing.rs
index 94b228466..501d44dbb 100644
--- a/crates/ra_ide_api/src/typing.rs
+++ b/crates/ra_ide_api/src/typing.rs
@@ -31,12 +31,14 @@ pub(crate) fn on_enter(db: &RootDatabase, position: FilePosition) -> Option<Sour
     let cursor_position = position.offset + TextUnit::of_str(&inserted);
     let mut edit = TextEditBuilder::default();
     edit.insert(position.offset, inserted);
-    Some(SourceChange {
-        label: "on enter".to_string(),
-        source_file_edits: vec![SourceFileEdit { edit: edit.finish(), file_id: position.file_id }],
-        file_system_edits: vec![],
-        cursor_position: Some(FilePosition { offset: cursor_position, file_id: position.file_id }),
-    })
+
+    Some(
+        SourceChange::source_file_edit(
+            "on enter",
+            SourceFileEdit { edit: edit.finish(), file_id: position.file_id },
+        )
+        .with_cursor(FilePosition { offset: cursor_position, file_id: position.file_id }),
+    )
 }
 
 fn node_indent<'a>(file: &'a SourceFile, node: &SyntaxNode) -> Option<&'a str> {
@@ -110,16 +112,14 @@ pub(crate) fn on_dot_typed(db: &RootDatabase, position: FilePosition) -> Option<
         TextRange::from_to(position.offset - current_indent_len, position.offset),
         target_indent.into(),
     );
-    let res = SourceChange {
-        label: "reindent dot".to_string(),
-        source_file_edits: vec![SourceFileEdit { edit: edit.finish(), file_id: position.file_id }],
-        file_system_edits: vec![],
-        cursor_position: Some(FilePosition {
+
+    let res = SourceChange::source_file_edit_from("reindent dot", position.file_id, edit.finish())
+        .with_cursor(FilePosition {
             offset: position.offset + target_indent_len - current_indent_len
                 + TextUnit::of_char('.'),
             file_id: position.file_id,
-        }),
-    };
+        });
+
     Some(res)
 }
 
diff --git a/crates/ra_ide_api/tests/test/main.rs b/crates/ra_ide_api/tests/test/main.rs
index 0f0766f62..d4ff21c09 100644
--- a/crates/ra_ide_api/tests/test/main.rs
+++ b/crates/ra_ide_api/tests/test/main.rs
@@ -1,4 +1,3 @@
-use insta::assert_debug_snapshot_matches;
 use ra_ide_api::{
     mock_analysis::{single_file, single_file_with_position, single_file_with_range, MockAnalysis},
     AnalysisChange, CrateGraph, Edition::Edition2018, Query, NavigationTarget,
@@ -7,21 +6,6 @@ use ra_ide_api::{
 use ra_syntax::SmolStr;
 
 #[test]
-fn test_unresolved_module_diagnostic() {
-    let (analysis, file_id) = single_file("mod foo;");
-    let diagnostics = analysis.diagnostics(file_id).unwrap();
-    assert_debug_snapshot_matches!("unresolved_module_diagnostic", &diagnostics);
-}
-
-// FIXME: move this test to hir
-#[test]
-fn test_unresolved_module_diagnostic_no_diag_for_inline_mode() {
-    let (analysis, file_id) = single_file("mod foo {}");
-    let diagnostics = analysis.diagnostics(file_id).unwrap();
-    assert!(diagnostics.is_empty());
-}
-
-#[test]
 fn test_resolve_crate_root() {
     let mock = MockAnalysis::with_files(
         "
diff --git a/crates/ra_ide_api/tests/test/snapshots/test__unresolved_module_diagnostic.snap b/crates/ra_ide_api/tests/test/snapshots/test__unresolved_module_diagnostic.snap
deleted file mode 100644
index 5bb953892..000000000
--- a/crates/ra_ide_api/tests/test/snapshots/test__unresolved_module_diagnostic.snap
+++ /dev/null
@@ -1,28 +0,0 @@
----
-created: "2019-01-22T14:45:01.486985900+00:00"
-creator: [email protected]
-expression: "&diagnostics"
-source: "crates\\ra_ide_api\\tests\\test\\main.rs"
----
-[
-    Diagnostic {
-        message: "unresolved module",
-        range: [0; 8),
-        fix: Some(
-            SourceChange {
-                label: "create module",
-                source_file_edits: [],
-                file_system_edits: [
-                    CreateFile {
-                        source_root: SourceRootId(
-                            0
-                        ),
-                        path: "foo.rs"
-                    }
-                ],
-                cursor_position: None
-            }
-        ),
-        severity: Error
-    }
-]
diff --git a/crates/ra_ide_api_light/Cargo.toml b/crates/ra_ide_api_light/Cargo.toml
deleted file mode 100644
index 4e69f5325..000000000
--- a/crates/ra_ide_api_light/Cargo.toml
+++ /dev/null
@@ -1,26 +0,0 @@
-[package]
-edition = "2018"
-name = "ra_ide_api_light"
-version = "0.1.0"
-authors = ["rust-analyzer developers"]
-publish = false
-
-[dependencies]
-itertools = "0.8.0"
-superslice = "1.0.0"
-join_to_string = "0.1.1"
-rustc-hash = "1.0"
-
-ra_syntax = { path = "../ra_syntax" }
-ra_text_edit = { path = "../ra_text_edit" }
-ra_fmt = { path = "../ra_fmt" }
-
-[dev-dependencies]
-test_utils = { path = "../test_utils" }
-insta = "0.7.0"
-
-[dev-dependencies.proptest]
-version = "0.9.0"
-# Disable `fork` feature to allow compiling on webassembly
-default-features = false
-features = ["std", "bit-set", "break-dead-code"]
diff --git a/crates/ra_ide_api_light/src/lib.rs b/crates/ra_ide_api_light/src/lib.rs
deleted file mode 100644
index df7f144b6..000000000
--- a/crates/ra_ide_api_light/src/lib.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//! This crate provides those IDE features which use only a single file.
-//!
-//! This usually means functions which take syntax tree as an input and produce
-//! an edit or some auxiliary info.
-
-mod structure;
-
-use ra_syntax::TextRange;
-
-pub use crate::{
-    structure::{file_structure, StructureNode},
-};
diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs
index d8c2cb063..a6fac07c4 100644
--- a/crates/ra_syntax/src/ast.rs
+++ b/crates/ra_syntax/src/ast.rs
@@ -521,7 +521,7 @@ pub enum PrefixOp {
 }
 
 impl PrefixExpr {
-    pub fn op(&self) -> Option<PrefixOp> {
+    pub fn op_kind(&self) -> Option<PrefixOp> {
         match self.syntax().first_child()?.kind() {
             STAR => Some(PrefixOp::Deref),
             EXCL => Some(PrefixOp::Not),
@@ -529,6 +529,10 @@ impl PrefixExpr {
             _ => None,
         }
     }
+
+    pub fn op(&self) -> Option<&SyntaxNode> {
+        self.syntax().first_child()
+    }
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
@@ -598,44 +602,49 @@ pub enum BinOp {
 }
 
 impl BinExpr {
-    pub fn op(&self) -> Option<BinOp> {
-        self.syntax()
-            .children()
-            .filter_map(|c| match c.kind() {
-                PIPEPIPE => Some(BinOp::BooleanOr),
-                AMPAMP => Some(BinOp::BooleanAnd),
-                EQEQ => Some(BinOp::EqualityTest),
-                NEQ => Some(BinOp::NegatedEqualityTest),
-                LTEQ => Some(BinOp::LesserEqualTest),
-                GTEQ => Some(BinOp::GreaterEqualTest),
-                L_ANGLE => Some(BinOp::LesserTest),
-                R_ANGLE => Some(BinOp::GreaterTest),
-                PLUS => Some(BinOp::Addition),
-                STAR => Some(BinOp::Multiplication),
-                MINUS => Some(BinOp::Subtraction),
-                SLASH => Some(BinOp::Division),
-                PERCENT => Some(BinOp::Remainder),
-                SHL => Some(BinOp::LeftShift),
-                SHR => Some(BinOp::RightShift),
-                CARET => Some(BinOp::BitwiseXor),
-                PIPE => Some(BinOp::BitwiseOr),
-                AMP => Some(BinOp::BitwiseAnd),
-                DOTDOT => Some(BinOp::RangeRightOpen),
-                DOTDOTEQ => Some(BinOp::RangeRightClosed),
-                EQ => Some(BinOp::Assignment),
-                PLUSEQ => Some(BinOp::AddAssign),
-                SLASHEQ => Some(BinOp::DivAssign),
-                STAREQ => Some(BinOp::MulAssign),
-                PERCENTEQ => Some(BinOp::RemAssign),
-                SHREQ => Some(BinOp::ShrAssign),
-                SHLEQ => Some(BinOp::ShlAssign),
-                MINUSEQ => Some(BinOp::SubAssign),
-                PIPEEQ => Some(BinOp::BitOrAssign),
-                AMPEQ => Some(BinOp::BitAndAssign),
-                CARETEQ => Some(BinOp::BitXorAssign),
-                _ => None,
-            })
-            .next()
+    fn op_details(&self) -> Option<(&SyntaxNode, BinOp)> {
+        self.syntax().children().find_map(|c| match c.kind() {
+            PIPEPIPE => Some((c, BinOp::BooleanOr)),
+            AMPAMP => Some((c, BinOp::BooleanAnd)),
+            EQEQ => Some((c, BinOp::EqualityTest)),
+            NEQ => Some((c, BinOp::NegatedEqualityTest)),
+            LTEQ => Some((c, BinOp::LesserEqualTest)),
+            GTEQ => Some((c, BinOp::GreaterEqualTest)),
+            L_ANGLE => Some((c, BinOp::LesserTest)),
+            R_ANGLE => Some((c, BinOp::GreaterTest)),
+            PLUS => Some((c, BinOp::Addition)),
+            STAR => Some((c, BinOp::Multiplication)),
+            MINUS => Some((c, BinOp::Subtraction)),
+            SLASH => Some((c, BinOp::Division)),
+            PERCENT => Some((c, BinOp::Remainder)),
+            SHL => Some((c, BinOp::LeftShift)),
+            SHR => Some((c, BinOp::RightShift)),
+            CARET => Some((c, BinOp::BitwiseXor)),
+            PIPE => Some((c, BinOp::BitwiseOr)),
+            AMP => Some((c, BinOp::BitwiseAnd)),
+            DOTDOT => Some((c, BinOp::RangeRightOpen)),
+            DOTDOTEQ => Some((c, BinOp::RangeRightClosed)),
+            EQ => Some((c, BinOp::Assignment)),
+            PLUSEQ => Some((c, BinOp::AddAssign)),
+            SLASHEQ => Some((c, BinOp::DivAssign)),
+            STAREQ => Some((c, BinOp::MulAssign)),
+            PERCENTEQ => Some((c, BinOp::RemAssign)),
+            SHREQ => Some((c, BinOp::ShrAssign)),
+            SHLEQ => Some((c, BinOp::ShlAssign)),
+            MINUSEQ => Some((c, BinOp::SubAssign)),
+            PIPEEQ => Some((c, BinOp::BitOrAssign)),
+            AMPEQ => Some((c, BinOp::BitAndAssign)),
+            CARETEQ => Some((c, BinOp::BitXorAssign)),
+            _ => None,
+        })
+    }
+
+    pub fn op_kind(&self) -> Option<BinOp> {
+        self.op_details().map(|t| t.1)
+    }
+
+    pub fn op(&self) -> Option<&SyntaxNode> {
+        self.op_details().map(|t| t.0)
     }
 
     pub fn lhs(&self) -> Option<&Expr> {
diff --git a/crates/ra_syntax/src/ptr.rs b/crates/ra_syntax/src/ptr.rs
index aae590cb6..d8de1c4c1 100644
--- a/crates/ra_syntax/src/ptr.rs
+++ b/crates/ra_syntax/src/ptr.rs
@@ -64,6 +64,12 @@ impl<N: AstNode> AstPtr<N> {
     }
 }
 
+impl<N: AstNode> From<AstPtr<N>> for SyntaxNodePtr {
+    fn from(ptr: AstPtr<N>) -> SyntaxNodePtr {
+        ptr.raw
+    }
+}
+
 #[test]
 fn test_local_syntax_ptr() {
     use crate::{ast, AstNode};