51 files changed, 3073 insertions, 254 deletions
diff --git a/crates/ra_assists/src/assists/add_explicit_type.rs b/crates/ra_assists/src/assists/add_explicit_type.rs
index eeb4ff39f..2c602a79e 100644
--- a/crates/ra_assists/src/assists/add_explicit_type.rs
+++ b/crates/ra_assists/src/assists/add_explicit_type.rs
@@ -74,6 +74,24 @@ mod tests {
    }
    #[test]
+    fn add_explicit_type_works_for_macro_call() {
+        check_assist(
+            add_explicit_type,
+            "macro_rules! v { () => {0u64} } fn f() { let a<|> = v!(); }",
+            "macro_rules! v { () => {0u64} } fn f() { let a<|>: u64 = v!(); }",
+        );
+    }
+    #[test]
+    fn add_explicit_type_works_for_macro_call_recursive() {
+        check_assist(
+            add_explicit_type,
+            "macro_rules! u { () => {0u64} } macro_rules! v { () => {u!()} } fn f() { let a<|> = v!(); }",
+            "macro_rules! u { () => {0u64} } macro_rules! v { () => {u!()} } fn f() { let a<|>: u64 = v!(); }",
+        );
+    }
+    #[test]
    fn add_explicit_type_not_applicable_if_ty_not_inferred() {
        check_assist_not_applicable(add_explicit_type, "fn f() { let a<|> = None; }");
    }
diff --git a/crates/ra_cargo_watch/Cargo.toml b/crates/ra_cargo_watch/Cargo.toml
new file mode 100644
index 000000000..bcc4648ff
--- /dev/null
+++ b/crates/ra_cargo_watch/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+edition = "2018"
+name = "ra_cargo_watch"
+version = "0.1.0"
+authors = ["rust-analyzer developers"]
+[dependencies]
+crossbeam-channel = "0.4"
+lsp-types = { version = "0.67.0", features = ["proposed"] }
+log = "0.4.3"
+cargo_metadata = "0.9.1"
+jod-thread = "0.1.0"
+parking_lot = "0.10.0"
+[dev-dependencies]
+insta = "0.12.0"
+serde_json = "1.0"
+\ No newline at end of file
diff --git a/crates/ra_cargo_watch/src/conv.rs b/crates/ra_cargo_watch/src/conv.rs
new file mode 100644
index 000000000..ac0f1d28a
--- /dev/null
+++ b/crates/ra_cargo_watch/src/conv.rs
@@ -0,0 +1,359 @@
+//! This module provides the functionality needed to convert diagnostics from
+//! `cargo check` json format to the LSP diagnostic format.
+use cargo_metadata::diagnostic::{
+    Applicability, Diagnostic as RustDiagnostic, DiagnosticLevel, DiagnosticSpan,
+    DiagnosticSpanMacroExpansion,
+};
+use lsp_types::{
+    Diagnostic, DiagnosticRelatedInformation, DiagnosticSeverity, DiagnosticTag, Location,
+    NumberOrString, Position, Range, Url,
+};
+use std::{
+    fmt::Write,
+    path::{Component, Path, PathBuf, Prefix},
+    str::FromStr,
+};
+#[cfg(test)]
+mod test;
+/// Converts a Rust level string to a LSP severity
+fn map_level_to_severity(val: DiagnosticLevel) -> Option<DiagnosticSeverity> {
+    match val {
+        DiagnosticLevel::Ice => Some(DiagnosticSeverity::Error),
+        DiagnosticLevel::Error => Some(DiagnosticSeverity::Error),
+        DiagnosticLevel::Warning => Some(DiagnosticSeverity::Warning),
+        DiagnosticLevel::Note => Some(DiagnosticSeverity::Information),
+        DiagnosticLevel::Help => Some(DiagnosticSeverity::Hint),
+        DiagnosticLevel::Unknown => None,
+    }
+}
+/// Check whether a file name is from macro invocation
+fn is_from_macro(file_name: &str) -> bool {
+    file_name.starts_with('<') && file_name.ends_with('>')
+}
+/// Converts a Rust macro span to a LSP location recursively
+fn map_macro_span_to_location(
+    span_macro: &DiagnosticSpanMacroExpansion,
+    workspace_root: &PathBuf,
+) -> Option<Location> {
+    if !is_from_macro(&span_macro.span.file_name) {
+        return Some(map_span_to_location(&span_macro.span, workspace_root));
+    }
+    if let Some(expansion) = &span_macro.span.expansion {
+        return map_macro_span_to_location(&expansion, workspace_root);
+    }
+    None
+}
+/// Converts a Rust span to a LSP location, resolving macro expansion site if neccesary
+fn map_span_to_location(span: &DiagnosticSpan, workspace_root: &PathBuf) -> Location {
+    if span.expansion.is_some() {
+        let expansion = span.expansion.as_ref().unwrap();
+        if let Some(macro_range) = map_macro_span_to_location(&expansion, workspace_root) {
+            return macro_range;
+        }
+    }
+    map_span_to_location_naive(span, workspace_root)
+}
+/// Converts a Rust span to a LSP location
+fn map_span_to_location_naive(span: &DiagnosticSpan, workspace_root: &PathBuf) -> Location {
+    let mut file_name = workspace_root.clone();
+    file_name.push(&span.file_name);
+    let uri = url_from_path_with_drive_lowercasing(file_name).unwrap();
+    let range = Range::new(
+        Position::new(span.line_start as u64 - 1, span.column_start as u64 - 1),
+        Position::new(span.line_end as u64 - 1, span.column_end as u64 - 1),
+    );
+    Location { uri, range }
+}
+/// Converts a secondary Rust span to a LSP related information
+///
+/// If the span is unlabelled this will return `None`.
+fn map_secondary_span_to_related(
+    span: &DiagnosticSpan,
+    workspace_root: &PathBuf,
+) -> Option<DiagnosticRelatedInformation> {
+    if let Some(label) = &span.label {
+        let location = map_span_to_location(span, workspace_root);
+        Some(DiagnosticRelatedInformation { location, message: label.clone() })
+    } else {
+        // Nothing to label this with
+        None
+    }
+}
+/// Determines if diagnostic is related to unused code
+fn is_unused_or_unnecessary(rd: &RustDiagnostic) -> bool {
+    if let Some(code) = &rd.code {
+        match code.code.as_str() {
+            "dead_code" | "unknown_lints" | "unreachable_code" | "unused_attributes"
+            | "unused_imports" | "unused_macros" | "unused_variables" => true,
+            _ => false,
+        }
+    } else {
+        false
+    }
+}
+/// Determines if diagnostic is related to deprecated code
+fn is_deprecated(rd: &RustDiagnostic) -> bool {
+    if let Some(code) = &rd.code {
+        match code.code.as_str() {
+            "deprecated" => true,
+            _ => false,
+        }
+    } else {
+        false
+    }
+}
+#[derive(Debug)]
+pub struct SuggestedFix {
+    pub title: String,
+    pub location: Location,
+    pub replacement: String,
+    pub applicability: Applicability,
+    pub diagnostics: Vec<Diagnostic>,
+}
+impl std::cmp::PartialEq<SuggestedFix> for SuggestedFix {
+    fn eq(&self, other: &SuggestedFix) -> bool {
+        if self.title == other.title
+            && self.location == other.location
+            && self.replacement == other.replacement
+        {
+            // Applicability doesn't impl PartialEq...
+            match (&self.applicability, &other.applicability) {
+                (Applicability::MachineApplicable, Applicability::MachineApplicable) => true,
+                (Applicability::HasPlaceholders, Applicability::HasPlaceholders) => true,
+                (Applicability::MaybeIncorrect, Applicability::MaybeIncorrect) => true,
+                (Applicability::Unspecified, Applicability::Unspecified) => true,
+                _ => false,
+            }
+        } else {
+            false
+        }
+    }
+}
+enum MappedRustChildDiagnostic {
+    Related(DiagnosticRelatedInformation),
+    SuggestedFix(SuggestedFix),
+    MessageLine(String),
+}
+fn map_rust_child_diagnostic(
+    rd: &RustDiagnostic,
+    workspace_root: &PathBuf,
+) -> MappedRustChildDiagnostic {
+    let span: &DiagnosticSpan = match rd.spans.iter().find(|s| s.is_primary) {
+        Some(span) => span,
+        None => {
+            // `rustc` uses these spanless children as a way to print multi-line
+            // messages
+            return MappedRustChildDiagnostic::MessageLine(rd.message.clone());
+        }
+    };
+    // If we have a primary span use its location, otherwise use the parent
+    let location = map_span_to_location(&span, workspace_root);
+    if let Some(suggested_replacement) = &span.suggested_replacement {
+        // Include our replacement in the title unless it's empty
+        let title = if !suggested_replacement.is_empty() {
+            format!("{}: '{}'", rd.message, suggested_replacement)
+        } else {
+            rd.message.clone()
+        };
+        MappedRustChildDiagnostic::SuggestedFix(SuggestedFix {
+            title,
+            location,
+            replacement: suggested_replacement.clone(),
+            applicability: span.suggestion_applicability.clone().unwrap_or(Applicability::Unknown),
+            diagnostics: vec![],
+        })
+    } else {
+        MappedRustChildDiagnostic::Related(DiagnosticRelatedInformation {
+            location,
+            message: rd.message.clone(),
+        })
+    }
+}
+#[derive(Debug)]
+pub(crate) struct MappedRustDiagnostic {
+    pub location: Location,
+    pub diagnostic: Diagnostic,
+    pub suggested_fixes: Vec<SuggestedFix>,
+}
+/// Converts a Rust root diagnostic to LSP form
+///
+/// This flattens the Rust diagnostic by:
+///
+/// 1. Creating a LSP diagnostic with the root message and primary span.
+/// 2. Adding any labelled secondary spans to `relatedInformation`
+/// 3. Categorising child diagnostics as either `SuggestedFix`es,
+///    `relatedInformation` or additional message lines.
+///
+/// If the diagnostic has no primary span this will return `None`
+pub(crate) fn map_rust_diagnostic_to_lsp(
+    rd: &RustDiagnostic,
+    workspace_root: &PathBuf,
+) -> Option<MappedRustDiagnostic> {
+    let primary_span = rd.spans.iter().find(|s| s.is_primary)?;
+    let location = map_span_to_location(&primary_span, workspace_root);
+    let severity = map_level_to_severity(rd.level);
+    let mut primary_span_label = primary_span.label.as_ref();
+    let mut source = String::from("rustc");
+    let mut code = rd.code.as_ref().map(|c| c.code.clone());
+    if let Some(code_val) = &code {
+        // See if this is an RFC #2103 scoped lint (e.g. from Clippy)
+        let scoped_code: Vec<&str> = code_val.split("::").collect();
+        if scoped_code.len() == 2 {
+            source = String::from(scoped_code[0]);
+            code = Some(String::from(scoped_code[1]));
+        }
+    }
+    let mut related_information = vec![];
+    let mut tags = vec![];
+    // If error occurs from macro expansion, add related info pointing to
+    // where the error originated
+    if !is_from_macro(&primary_span.file_name) && primary_span.expansion.is_some() {
+        let def_loc = map_span_to_location_naive(&primary_span, workspace_root);
+        related_information.push(DiagnosticRelatedInformation {
+            location: def_loc,
+            message: "Error originated from macro here".to_string(),
+        });
+    }
+    for secondary_span in rd.spans.iter().filter(|s| !s.is_primary) {
+        let related = map_secondary_span_to_related(secondary_span, workspace_root);
+        if let Some(related) = related {
+            related_information.push(related);
+        }
+    }
+    let mut suggested_fixes = vec![];
+    let mut message = rd.message.clone();
+    for child in &rd.children {
+        let child = map_rust_child_diagnostic(&child, workspace_root);
+        match child {
+            MappedRustChildDiagnostic::Related(related) => related_information.push(related),
+            MappedRustChildDiagnostic::SuggestedFix(suggested_fix) => {
+                suggested_fixes.push(suggested_fix)
+            }
+            MappedRustChildDiagnostic::MessageLine(message_line) => {
+                write!(&mut message, "\n{}", message_line).unwrap();
+                // These secondary messages usually duplicate the content of the
+                // primary span label.
+                primary_span_label = None;
+            }
+        }
+    }
+    if let Some(primary_span_label) = primary_span_label {
+        write!(&mut message, "\n{}", primary_span_label).unwrap();
+    }
+    if is_unused_or_unnecessary(rd) {
+        tags.push(DiagnosticTag::Unnecessary);
+    }
+    if is_deprecated(rd) {
+        tags.push(DiagnosticTag::Deprecated);
+    }
+    let diagnostic = Diagnostic {
+        range: location.range,
+        severity,
+        code: code.map(NumberOrString::String),
+        source: Some(source),
+        message,
+        related_information: if !related_information.is_empty() {
+            Some(related_information)
+        } else {
+            None
+        },
+        tags: if !tags.is_empty() { Some(tags) } else { None },
+    };
+    Some(MappedRustDiagnostic { location, diagnostic, suggested_fixes })
+}
+/// Returns a `Url` object from a given path, will lowercase drive letters if present.
+/// This will only happen when processing windows paths.
+///
+/// When processing non-windows path, this is essentially the same as `Url::from_file_path`.
+pub fn url_from_path_with_drive_lowercasing(
+    path: impl AsRef<Path>,
+) -> Result<Url, Box<dyn std::error::Error + Send + Sync>> {
+    let component_has_windows_drive = path.as_ref().components().any(|comp| {
+        if let Component::Prefix(c) = comp {
+            match c.kind() {
+                Prefix::Disk(_) | Prefix::VerbatimDisk(_) => return true,
+                _ => return false,
+            }
+        }
+        false
+    });
+    // VSCode expects drive letters to be lowercased, where rust will uppercase the drive letters.
+    if component_has_windows_drive {
+        let url_original = Url::from_file_path(&path)
+            .map_err(|_| format!("can't convert path to url: {}", path.as_ref().display()))?;
+        let drive_partition: Vec<&str> = url_original.as_str().rsplitn(2, ':').collect();
+        // There is a drive partition, but we never found a colon.
+        // This should not happen, but in this case we just pass it through.
+        if drive_partition.len() == 1 {
+            return Ok(url_original);
+        }
+        let joined = drive_partition[1].to_ascii_lowercase() + ":" + drive_partition[0];
+        let url = Url::from_str(&joined).expect("This came from a valid `Url`");
+        Ok(url)
+    } else {
+        Ok(Url::from_file_path(&path)
+            .map_err(|_| format!("can't convert path to url: {}", path.as_ref().display()))?)
+    }
+}
+// `Url` is not able to parse windows paths on unix machines.
+#[cfg(target_os = "windows")]
+#[cfg(test)]
+mod path_conversion_windows_tests {
+    use super::url_from_path_with_drive_lowercasing;
+    #[test]
+    fn test_lowercase_drive_letter_with_drive() {
+        let url = url_from_path_with_drive_lowercasing("C:\\Test").unwrap();
+        assert_eq!(url.to_string(), "file:///c:/Test");
+    }
+    #[test]
+    fn test_drive_without_colon_passthrough() {
+        let url = url_from_path_with_drive_lowercasing(r#"\\localhost\C$\my_dir"#).unwrap();
+        assert_eq!(url.to_string(), "file://localhost/C$/my_dir");
+    }
+}
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/test__snap_clippy_pass_by_ref.snap b/crates/ra_cargo_watch/src/conv/snapshots/test__snap_clippy_pass_by_ref.snap
new file mode 100644
index 000000000..cb0920914
--- /dev/null
+++ b/crates/ra_cargo_watch/src/conv/snapshots/test__snap_clippy_pass_by_ref.snap
@@ -0,0 +1,85 @@
+---
+source: crates/ra_cargo_watch/src/conv/test.rs
+expression: diag
+---
+MappedRustDiagnostic {
+    location: Location {
+        uri: "file:///test/compiler/mir/tagset.rs",
+        range: Range {
+            start: Position {
+                line: 41,
+                character: 23,
+            },
+            end: Position {
+                line: 41,
+                character: 28,
+            },
+        },
+    },
+    diagnostic: Diagnostic {
+        range: Range {
+            start: Position {
+                line: 41,
+                character: 23,
+            },
+            end: Position {
+                line: 41,
+                character: 28,
+            },
+        },
+        severity: Some(
+            Warning,
+        ),
+        code: Some(
+            String(
+                "trivially_copy_pass_by_ref",
+            ),
+        ),
+        source: Some(
+            "clippy",
+        ),
+        message: "this argument is passed by reference, but would be more efficient if passed by value\n#[warn(clippy::trivially_copy_pass_by_ref)] implied by #[warn(clippy::all)]\nfor further information visit https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref",
+        related_information: Some(
+            [
+                DiagnosticRelatedInformation {
+                    location: Location {
+                        uri: "file:///test/compiler/lib.rs",
+                        range: Range {
+                            start: Position {
+                                line: 0,
+                                character: 8,
+                            },
+                            end: Position {
+                                line: 0,
+                                character: 19,
+                            },
+                        },
+                    },
+                    message: "lint level defined here",
+                },
+            ],
+        ),
+        tags: None,
+    },
+    suggested_fixes: [
+        SuggestedFix {
+            title: "consider passing by value instead: \'self\'",
+            location: Location {
+                uri: "file:///test/compiler/mir/tagset.rs",
+                range: Range {
+                    start: Position {
+                        line: 41,
+                        character: 23,
+                    },
+                    end: Position {
+                        line: 41,
+                        character: 28,
+                    },
+                },
+            },
+            replacement: "self",
+            applicability: Unspecified,
+            diagnostics: [],
+        },
+    ],
+}
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/test__snap_handles_macro_location.snap b/crates/ra_cargo_watch/src/conv/snapshots/test__snap_handles_macro_location.snap
new file mode 100644
index 000000000..19510ecc1
--- /dev/null
+++ b/crates/ra_cargo_watch/src/conv/snapshots/test__snap_handles_macro_location.snap
@@ -0,0 +1,46 @@
+---
+source: crates/ra_cargo_watch/src/conv/test.rs
+expression: diag
+---
+MappedRustDiagnostic {
+    location: Location {
+        uri: "file:///test/src/main.rs",
+        range: Range {
+            start: Position {
+                line: 1,
+                character: 4,
+            },
+            end: Position {
+                line: 1,
+                character: 26,
+            },
+        },
+    },
+    diagnostic: Diagnostic {
+        range: Range {
+            start: Position {
+                line: 1,
+                character: 4,
+            },
+            end: Position {
+                line: 1,
+                character: 26,
+            },
+        },
+        severity: Some(
+            Error,
+        ),
+        code: Some(
+            String(
+                "E0277",
+            ),
+        ),
+        source: Some(
+            "rustc",
+        ),
+        message: "can\'t compare `{integer}` with `&str`\nthe trait `std::cmp::PartialEq<&str>` is not implemented for `{integer}`",
+        related_information: None,
+        tags: None,
+    },
+    suggested_fixes: [],
+}
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/test__snap_macro_compiler_error.snap b/crates/ra_cargo_watch/src/conv/snapshots/test__snap_macro_compiler_error.snap
new file mode 100644
index 000000000..92f7eec05
--- /dev/null
+++ b/crates/ra_cargo_watch/src/conv/snapshots/test__snap_macro_compiler_error.snap
@@ -0,0 +1,61 @@
+---
+source: crates/ra_cargo_watch/src/conv/test.rs
+expression: diag
+---
+MappedRustDiagnostic {
+    location: Location {
+        uri: "file:///test/crates/ra_hir_def/src/data.rs",
+        range: Range {
+            start: Position {
+                line: 79,
+                character: 15,
+            },
+            end: Position {
+                line: 79,
+                character: 41,
+            },
+        },
+    },
+    diagnostic: Diagnostic {
+        range: Range {
+            start: Position {
+                line: 79,
+                character: 15,
+            },
+            end: Position {
+                line: 79,
+                character: 41,
+            },
+        },
+        severity: Some(
+            Error,
+        ),
+        code: None,
+        source: Some(
+            "rustc",
+        ),
+        message: "Please register your known path in the path module",
+        related_information: Some(
+            [
+                DiagnosticRelatedInformation {
+                    location: Location {
+                        uri: "file:///test/crates/ra_hir_def/src/path.rs",
+                        range: Range {
+                            start: Position {
+                                line: 264,
+                                character: 8,
+                            },
+                            end: Position {
+                                line: 264,
+                                character: 76,
+                            },
+                        },
+                    },
+                    message: "Error originated from macro here",
+                },
+            ],
+        ),
+        tags: None,
+    },
+    suggested_fixes: [],
+}
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_incompatible_type_for_trait.snap b/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_incompatible_type_for_trait.snap
new file mode 100644
index 000000000..cf683e4b6
--- /dev/null
+++ b/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_incompatible_type_for_trait.snap
@@ -0,0 +1,46 @@
+---
+source: crates/ra_cargo_watch/src/conv/test.rs
+expression: diag
+---
+MappedRustDiagnostic {
+    location: Location {
+        uri: "file:///test/compiler/ty/list_iter.rs",
+        range: Range {
+            start: Position {
+                line: 51,
+                character: 4,
+            },
+            end: Position {
+                line: 51,
+                character: 47,
+            },
+        },
+    },
+    diagnostic: Diagnostic {
+        range: Range {
+            start: Position {
+                line: 51,
+                character: 4,
+            },
+            end: Position {
+                line: 51,
+                character: 47,
+            },
+        },
+        severity: Some(
+            Error,
+        ),
+        code: Some(
+            String(
+                "E0053",
+            ),
+        ),
+        source: Some(
+            "rustc",
+        ),
+        message: "method `next` has an incompatible type for trait\nexpected type `fn(&mut ty::list_iter::ListIterator<\'list, M>) -> std::option::Option<&ty::Ref<M>>`\n   found type `fn(&ty::list_iter::ListIterator<\'list, M>) -> std::option::Option<&\'list ty::Ref<M>>`",
+        related_information: None,
+        tags: None,
+    },
+    suggested_fixes: [],
+}
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_mismatched_type.snap b/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_mismatched_type.snap
new file mode 100644
index 000000000..8c1483c74
--- /dev/null
+++ b/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_mismatched_type.snap
@@ -0,0 +1,46 @@
+---
+source: crates/ra_cargo_watch/src/conv/test.rs
+expression: diag
+---
+MappedRustDiagnostic {
+    location: Location {
+        uri: "file:///test/runtime/compiler_support.rs",
+        range: Range {
+            start: Position {
+                line: 47,
+                character: 64,
+            },
+            end: Position {
+                line: 47,
+                character: 69,
+            },
+        },
+    },
+    diagnostic: Diagnostic {
+        range: Range {
+            start: Position {
+                line: 47,
+                character: 64,
+            },
+            end: Position {
+                line: 47,
+                character: 69,
+            },
+        },
+        severity: Some(
+            Error,
+        ),
+        code: Some(
+            String(
+                "E0308",
+            ),
+        ),
+        source: Some(
+            "rustc",
+        ),
+        message: "mismatched types\nexpected usize, found u32",
+        related_information: None,
+        tags: None,
+    },
+    suggested_fixes: [],
+}
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_unused_variable.snap b/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_unused_variable.snap
new file mode 100644
index 000000000..eb5a2247b
--- /dev/null
+++ b/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_unused_variable.snap
@@ -0,0 +1,70 @@
+---
+source: crates/ra_cargo_watch/src/conv/test.rs
+expression: diag
+---
+MappedRustDiagnostic {
+    location: Location {
+        uri: "file:///test/driver/subcommand/repl.rs",
+        range: Range {
+            start: Position {
+                line: 290,
+                character: 8,
+            },
+            end: Position {
+                line: 290,
+                character: 11,
+            },
+        },
+    },
+    diagnostic: Diagnostic {
+        range: Range {
+            start: Position {
+                line: 290,
+                character: 8,
+            },
+            end: Position {
+                line: 290,
+                character: 11,
+            },
+        },
+        severity: Some(
+            Warning,
+        ),
+        code: Some(
+            String(
+                "unused_variables",
+            ),
+        ),
+        source: Some(
+            "rustc",
+        ),
+        message: "unused variable: `foo`\n#[warn(unused_variables)] on by default",
+        related_information: None,
+        tags: Some(
+            [
+                Unnecessary,
+            ],
+        ),
+    },
+    suggested_fixes: [
+        SuggestedFix {
+            title: "consider prefixing with an underscore: \'_foo\'",
+            location: Location {
+                uri: "file:///test/driver/subcommand/repl.rs",
+                range: Range {
+                    start: Position {
+                        line: 290,
+                        character: 8,
+                    },
+                    end: Position {
+                        line: 290,
+                        character: 11,
+                    },
+                },
+            },
+            replacement: "_foo",
+            applicability: MachineApplicable,
+            diagnostics: [],
+        },
+    ],
+}
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_wrong_number_of_parameters.snap b/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_wrong_number_of_parameters.snap
new file mode 100644
index 000000000..2f4518931
--- /dev/null
+++ b/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_wrong_number_of_parameters.snap
@@ -0,0 +1,65 @@
+---
+source: crates/ra_cargo_watch/src/conv/test.rs
+expression: diag
+---
+MappedRustDiagnostic {
+    location: Location {
+        uri: "file:///test/compiler/ty/select.rs",
+        range: Range {
+            start: Position {
+                line: 103,
+                character: 17,
+            },
+            end: Position {
+                line: 103,
+                character: 29,
+            },
+        },
+    },
+    diagnostic: Diagnostic {
+        range: Range {
+            start: Position {
+                line: 103,
+                character: 17,
+            },
+            end: Position {
+                line: 103,
+                character: 29,
+            },
+        },
+        severity: Some(
+            Error,
+        ),
+        code: Some(
+            String(
+                "E0061",
+            ),
+        ),
+        source: Some(
+            "rustc",
+        ),
+        message: "this function takes 2 parameters but 3 parameters were supplied\nexpected 2 parameters",
+        related_information: Some(
+            [
+                DiagnosticRelatedInformation {
+                    location: Location {
+                        uri: "file:///test/compiler/ty/select.rs",
+                        range: Range {
+                            start: Position {
+                                line: 218,
+                                character: 4,
+                            },
+                            end: Position {
+                                line: 230,
+                                character: 5,
+                            },
+                        },
+                    },
+                    message: "defined here",
+                },
+            ],
+        ),
+        tags: None,
+    },
+    suggested_fixes: [],
+}
diff --git a/crates/ra_cargo_watch/src/conv/test.rs b/crates/ra_cargo_watch/src/conv/test.rs
new file mode 100644
index 000000000..381992388
--- /dev/null
+++ b/crates/ra_cargo_watch/src/conv/test.rs
@@ -0,0 +1,929 @@
+//! This module contains the large and verbose snapshot tests for the
+//! conversions between `cargo check` json and LSP diagnostics.
+use crate::*;
+fn parse_diagnostic(val: &str) -> cargo_metadata::diagnostic::Diagnostic {
+    serde_json::from_str::<cargo_metadata::diagnostic::Diagnostic>(val).unwrap()
+}
+#[test]
+fn snap_rustc_incompatible_type_for_trait() {
+    let diag = parse_diagnostic(
+        r##"{
+            "message": "method `next` has an incompatible type for trait",
+            "code": {
+                "code": "E0053",
+                "explanation": "\nThe parameters of any trait method must match between a trait implementation\nand the trait definition.\n\nHere are a couple examples of this error:\n\n```compile_fail,E0053\ntrait Foo {\n    fn foo(x: u16);\n    fn bar(&self);\n}\n\nstruct Bar;\n\nimpl Foo for Bar {\n    // error, expected u16, found i16\n    fn foo(x: i16) { }\n\n    // error, types differ in mutability\n    fn bar(&mut self) { }\n}\n```\n"
+            },
+            "level": "error",
+            "spans": [
+                {
+                    "file_name": "compiler/ty/list_iter.rs",
+                    "byte_start": 1307,
+                    "byte_end": 1350,
+                    "line_start": 52,
+                    "line_end": 52,
+                    "column_start": 5,
+                    "column_end": 48,
+                    "is_primary": true,
+                    "text": [
+                        {
+                            "text": "    fn next(&self) -> Option<&'list ty::Ref<M>> {",
+                            "highlight_start": 5,
+                            "highlight_end": 48
+                        }
+                    ],
+                    "label": "types differ in mutability",
+                    "suggested_replacement": null,
+                    "suggestion_applicability": null,
+                    "expansion": null
+                }
+            ],
+            "children": [
+                {
+                    "message": "expected type `fn(&mut ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&ty::Ref<M>>`\n   found type `fn(&ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&'list ty::Ref<M>>`",
+                    "code": null,
+                    "level": "note",
+                    "spans": [],
+                    "children": [],
+                    "rendered": null
+                }
+            ],
+            "rendered": "error[E0053]: method `next` has an incompatible type for trait\n  --> compiler/ty/list_iter.rs:52:5\n   |\n52 |     fn next(&self) -> Option<&'list ty::Ref<M>> {\n   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ types differ in mutability\n   |\n   = note: expected type `fn(&mut ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&ty::Ref<M>>`\n              found type `fn(&ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&'list ty::Ref<M>>`\n\n"
+        }
+        "##,
+    );
+    let workspace_root = PathBuf::from("/test/");
+    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root).expect("couldn't map diagnostic");
+    insta::assert_debug_snapshot!(diag);
+}
+#[test]
+fn snap_rustc_unused_variable() {
+    let diag = parse_diagnostic(
+        r##"{
+"message": "unused variable: `foo`",
+"code": {
+    "code": "unused_variables",
+    "explanation": null
+},
+"level": "warning",
+"spans": [
+    {
+        "file_name": "driver/subcommand/repl.rs",
+        "byte_start": 9228,
+        "byte_end": 9231,
+        "line_start": 291,
+        "line_end": 291,
+        "column_start": 9,
+        "column_end": 12,
+        "is_primary": true,
+        "text": [
+            {
+                "text": "    let foo = 42;",
+                "highlight_start": 9,
+                "highlight_end": 12
+            }
+        ],
+        "label": null,
+        "suggested_replacement": null,
+        "suggestion_applicability": null,
+        "expansion": null
+    }
+],
+"children": [
+    {
+        "message": "#[warn(unused_variables)] on by default",
+        "code": null,
+        "level": "note",
+        "spans": [],
+        "children": [],
+        "rendered": null
+    },
+    {
+        "message": "consider prefixing with an underscore",
+        "code": null,
+        "level": "help",
+        "spans": [
+            {
+                "file_name": "driver/subcommand/repl.rs",
+                "byte_start": 9228,
+                "byte_end": 9231,
+                "line_start": 291,
+                "line_end": 291,
+                "column_start": 9,
+                "column_end": 12,
+                "is_primary": true,
+                "text": [
+                    {
+                        "text": "    let foo = 42;",
+                        "highlight_start": 9,
+                        "highlight_end": 12
+                    }
+                ],
+                "label": null,
+                "suggested_replacement": "_foo",
+                "suggestion_applicability": "MachineApplicable",
+                "expansion": null
+            }
+        ],
+        "children": [],
+        "rendered": null
+    }
+],
+"rendered": "warning: unused variable: `foo`\n   --> driver/subcommand/repl.rs:291:9\n    |\n291 |     let foo = 42;\n    |         ^^^ help: consider prefixing with an underscore: `_foo`\n    |\n    = note: #[warn(unused_variables)] on by default\n\n"
+}"##,
+    );
+    let workspace_root = PathBuf::from("/test/");
+    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root).expect("couldn't map diagnostic");
+    insta::assert_debug_snapshot!(diag);
+}
+#[test]
+fn snap_rustc_wrong_number_of_parameters() {
+    let diag = parse_diagnostic(
+        r##"{
+"message": "this function takes 2 parameters but 3 parameters were supplied",
+"code": {
+    "code": "E0061",
+    "explanation": "\nThe number of arguments passed to a function must match the number of arguments\nspecified in the function signature.\n\nFor example, a function like:\n\n```\nfn f(a: u16, b: &str) {}\n```\n\nMust always be called with exactly two arguments, e.g., `f(2, \"test\")`.\n\nNote that Rust does not have a notion of optional function arguments or\nvariadic functions (except for its C-FFI).\n"
+},
+"level": "error",
+"spans": [
+    {
+        "file_name": "compiler/ty/select.rs",
+        "byte_start": 8787,
+        "byte_end": 9241,
+        "line_start": 219,
+        "line_end": 231,
+        "column_start": 5,
+        "column_end": 6,
+        "is_primary": false,
+        "text": [
+            {
+                "text": "    pub fn add_evidence(",
+                "highlight_start": 5,
+                "highlight_end": 25
+            },
+            {
+                "text": "        &mut self,",
+                "highlight_start": 1,
+                "highlight_end": 19
+            },
+            {
+                "text": "        target_poly: &ty::Ref<ty::Poly>,",
+                "highlight_start": 1,
+                "highlight_end": 41
+            },
+            {
+                "text": "        evidence_poly: &ty::Ref<ty::Poly>,",
+                "highlight_start": 1,
+                "highlight_end": 43
+            },
+            {
+                "text": "    ) {",
+                "highlight_start": 1,
+                "highlight_end": 8
+            },
+            {
+                "text": "        match target_poly {",
+                "highlight_start": 1,
+                "highlight_end": 28
+            },
+            {
+                "text": "            ty::Ref::Var(tvar, _) => self.add_var_evidence(tvar, evidence_poly),",
+                "highlight_start": 1,
+                "highlight_end": 81
+            },
+            {
+                "text": "            ty::Ref::Fixed(target_ty) => {",
+                "highlight_start": 1,
+                "highlight_end": 43
+            },
+            {
+                "text": "                let evidence_ty = evidence_poly.resolve_to_ty();",
+                "highlight_start": 1,
+                "highlight_end": 65
+            },
+            {
+                "text": "                self.add_evidence_ty(target_ty, evidence_poly, evidence_ty)",
+                "highlight_start": 1,
+                "highlight_end": 76
+            },
+            {
+                "text": "            }",
+                "highlight_start": 1,
+                "highlight_end": 14
+            },
+            {
+                "text": "        }",
+                "highlight_start": 1,
+                "highlight_end": 10
+            },
+            {
+                "text": "    }",
+                "highlight_start": 1,
+                "highlight_end": 6
+            }
+        ],
+        "label": "defined here",
+        "suggested_replacement": null,
+        "suggestion_applicability": null,
+        "expansion": null
+    },
+    {
+        "file_name": "compiler/ty/select.rs",
+        "byte_start": 4045,
+        "byte_end": 4057,
+        "line_start": 104,
+        "line_end": 104,
+        "column_start": 18,
+        "column_end": 30,
+        "is_primary": true,
+        "text": [
+            {
+                "text": "            self.add_evidence(target_fixed, evidence_fixed, false);",
+                "highlight_start": 18,
+                "highlight_end": 30
+            }
+        ],
+        "label": "expected 2 parameters",
+        "suggested_replacement": null,
+        "suggestion_applicability": null,
+        "expansion": null
+    }
+],
+"children": [],
+"rendered": "error[E0061]: this function takes 2 parameters but 3 parameters were supplied\n   --> compiler/ty/select.rs:104:18\n    |\n104 |               self.add_evidence(target_fixed, evidence_fixed, false);\n    |                    ^^^^^^^^^^^^ expected 2 parameters\n...\n219 | /     pub fn add_evidence(\n220 | |         &mut self,\n221 | |         target_poly: &ty::Ref<ty::Poly>,\n222 | |         evidence_poly: &ty::Ref<ty::Poly>,\n...   |\n230 | |         }\n231 | |     }\n    | |_____- defined here\n\n"
+}"##,
+    );
+    let workspace_root = PathBuf::from("/test/");
+    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root).expect("couldn't map diagnostic");
+    insta::assert_debug_snapshot!(diag);
+}
+#[test]
+fn snap_clippy_pass_by_ref() {
+    let diag = parse_diagnostic(
+        r##"{
+"message": "this argument is passed by reference, but would be more efficient if passed by value",
+"code": {
+    "code": "clippy::trivially_copy_pass_by_ref",
+    "explanation": null
+},
+"level": "warning",
+"spans": [
+    {
+        "file_name": "compiler/mir/tagset.rs",
+        "byte_start": 941,
+        "byte_end": 946,
+        "line_start": 42,
+        "line_end": 42,
+        "column_start": 24,
+        "column_end": 29,
+        "is_primary": true,
+        "text": [
+            {
+                "text": "    pub fn is_disjoint(&self, other: Self) -> bool {",
+                "highlight_start": 24,
+                "highlight_end": 29
+            }
+        ],
+        "label": null,
+        "suggested_replacement": null,
+        "suggestion_applicability": null,
+        "expansion": null
+    }
+],
+"children": [
+    {
+        "message": "lint level defined here",
+        "code": null,
+        "level": "note",
+        "spans": [
+            {
+                "file_name": "compiler/lib.rs",
+                "byte_start": 8,
+                "byte_end": 19,
+                "line_start": 1,
+                "line_end": 1,
+                "column_start": 9,
+                "column_end": 20,
+                "is_primary": true,
+                "text": [
+                    {
+                        "text": "#![warn(clippy::all)]",
+                        "highlight_start": 9,
+                        "highlight_end": 20
+                    }
+                ],
+                "label": null,
+                "suggested_replacement": null,
+                "suggestion_applicability": null,
+                "expansion": null
+            }
+        ],
+        "children": [],
+        "rendered": null
+    },
+    {
+        "message": "#[warn(clippy::trivially_copy_pass_by_ref)] implied by #[warn(clippy::all)]",
+        "code": null,
+        "level": "note",
+        "spans": [],
+        "children": [],
+        "rendered": null
+    },
+    {
+        "message": "for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref",
+        "code": null,
+        "level": "help",
+        "spans": [],
+        "children": [],
+        "rendered": null
+    },
+    {
+        "message": "consider passing by value instead",
+        "code": null,
+        "level": "help",
+        "spans": [
+            {
+                "file_name": "compiler/mir/tagset.rs",
+                "byte_start": 941,
+                "byte_end": 946,
+                "line_start": 42,
+                "line_end": 42,
+                "column_start": 24,
+                "column_end": 29,
+                "is_primary": true,
+                "text": [
+                    {
+                        "text": "    pub fn is_disjoint(&self, other: Self) -> bool {",
+                        "highlight_start": 24,
+                        "highlight_end": 29
+                    }
+                ],
+                "label": null,
+                "suggested_replacement": "self",
+                "suggestion_applicability": "Unspecified",
+                "expansion": null
+            }
+        ],
+        "children": [],
+        "rendered": null
+    }
+],
+"rendered": "warning: this argument is passed by reference, but would be more efficient if passed by value\n  --> compiler/mir/tagset.rs:42:24\n   |\n42 |     pub fn is_disjoint(&self, other: Self) -> bool {\n   |                        ^^^^^ help: consider passing by value instead: `self`\n   |\nnote: lint level defined here\n  --> compiler/lib.rs:1:9\n   |\n1  | #![warn(clippy::all)]\n   |         ^^^^^^^^^^^\n   = note: #[warn(clippy::trivially_copy_pass_by_ref)] implied by #[warn(clippy::all)]\n   = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref\n\n"
+}"##,
+    );
+    let workspace_root = PathBuf::from("/test/");
+    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root).expect("couldn't map diagnostic");
+    insta::assert_debug_snapshot!(diag);
+}
+#[test]
+fn snap_rustc_mismatched_type() {
+    let diag = parse_diagnostic(
+        r##"{
+"message": "mismatched types",
+"code": {
+    "code": "E0308",
+    "explanation": "\nThis error occurs when the compiler was unable to infer the concrete type of a\nvariable. It can occur for several cases, the most common of which is a\nmismatch in the expected type that the compiler inferred for a variable's\ninitializing expression, and the actual type explicitly assigned to the\nvariable.\n\nFor example:\n\n```compile_fail,E0308\nlet x: i32 = \"I am not a number!\";\n//     ~~~   ~~~~~~~~~~~~~~~~~~~~\n//      |             |\n//      |    initializing expression;\n//      |    compiler infers type `&str`\n//      |\n//    type `i32` assigned to variable `x`\n```\n"
+},
+"level": "error",
+"spans": [
+    {
+        "file_name": "runtime/compiler_support.rs",
+        "byte_start": 1589,
+        "byte_end": 1594,
+        "line_start": 48,
+        "line_end": 48,
+        "column_start": 65,
+        "column_end": 70,
+        "is_primary": true,
+        "text": [
+            {
+                "text": "    let layout = alloc::Layout::from_size_align_unchecked(size, align);",
+                "highlight_start": 65,
+                "highlight_end": 70
+            }
+        ],
+        "label": "expected usize, found u32",
+        "suggested_replacement": null,
+        "suggestion_applicability": null,
+        "expansion": null
+    }
+],
+"children": [],
+"rendered": "error[E0308]: mismatched types\n  --> runtime/compiler_support.rs:48:65\n   |\n48 |     let layout = alloc::Layout::from_size_align_unchecked(size, align);\n   |                                                                 ^^^^^ expected usize, found u32\n\n"
+}"##,
+    );
+    let workspace_root = PathBuf::from("/test/");
+    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root).expect("couldn't map diagnostic");
+    insta::assert_debug_snapshot!(diag);
+}
+#[test]
+fn snap_handles_macro_location() {
+    let diag = parse_diagnostic(
+        r##"{
+"rendered": "error[E0277]: can't compare `{integer}` with `&str`\n --> src/main.rs:2:5\n  |\n2 |     assert_eq!(1, \"love\");\n  |     ^^^^^^^^^^^^^^^^^^^^^^ no implementation for `{integer} == &str`\n  |\n  = help: the trait `std::cmp::PartialEq<&str>` is not implemented for `{integer}`\n  = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)\n\n",
+"children": [
+    {
+        "children": [],
+        "code": null,
+        "level": "help",
+        "message": "the trait `std::cmp::PartialEq<&str>` is not implemented for `{integer}`",
+        "rendered": null,
+        "spans": []
+    }
+],
+"code": {
+    "code": "E0277",
+    "explanation": "\nYou tried to use a type which doesn't implement some trait in a place which\nexpected that trait. Erroneous code example:\n\n```compile_fail,E0277\n// here we declare the Foo trait with a bar method\ntrait Foo {\n    fn bar(&self);\n}\n\n// we now declare a function which takes an object implementing the Foo trait\nfn some_func<T: Foo>(foo: T) {\n    foo.bar();\n}\n\nfn main() {\n    // we now call the method with the i32 type, which doesn't implement\n    // the Foo trait\n    some_func(5i32); // error: the trait bound `i32 : Foo` is not satisfied\n}\n```\n\nIn order to fix this error, verify that the type you're using does implement\nthe trait. Example:\n\n```\ntrait Foo {\n    fn bar(&self);\n}\n\nfn some_func<T: Foo>(foo: T) {\n    foo.bar(); // we can now use this method since i32 implements the\n               // Foo trait\n}\n\n// we implement the trait on the i32 type\nimpl Foo for i32 {\n    fn bar(&self) {}\n}\n\nfn main() {\n    some_func(5i32); // ok!\n}\n```\n\nOr in a generic context, an erroneous code example would look like:\n\n```compile_fail,E0277\nfn some_func<T>(foo: T) {\n    println!(\"{:?}\", foo); // error: the trait `core::fmt::Debug` is not\n                           //        implemented for the type `T`\n}\n\nfn main() {\n    // We now call the method with the i32 type,\n    // which *does* implement the Debug trait.\n    some_func(5i32);\n}\n```\n\nNote that the error here is in the definition of the generic function: Although\nwe only call it with a parameter that does implement `Debug`, the compiler\nstill rejects the function: It must work with all possible input types. In\norder to make this example compile, we need to restrict the generic type we're\naccepting:\n\n```\nuse std::fmt;\n\n// Restrict the input type to types that implement Debug.\nfn some_func<T: fmt::Debug>(foo: T) {\n    println!(\"{:?}\", foo);\n}\n\nfn main() {\n    // Calling the method is still fine, as i32 implements Debug.\n    some_func(5i32);\n\n    // This would fail to compile now:\n    // struct WithoutDebug;\n    // some_func(WithoutDebug);\n}\n```\n\nRust only looks at the signature of the called function, as such it must\nalready specify all requirements that will be used for every type parameter.\n"
+},
+"level": "error",
+"message": "can't compare `{integer}` with `&str`",
+"spans": [
+    {
+        "byte_end": 155,
+        "byte_start": 153,
+        "column_end": 33,
+        "column_start": 31,
+        "expansion": {
+            "def_site_span": {
+                "byte_end": 940,
+                "byte_start": 0,
+                "column_end": 6,
+                "column_start": 1,
+                "expansion": null,
+                "file_name": "<::core::macros::assert_eq macros>",
+                "is_primary": false,
+                "label": null,
+                "line_end": 36,
+                "line_start": 1,
+                "suggested_replacement": null,
+                "suggestion_applicability": null,
+                "text": [
+                    {
+                        "highlight_end": 35,
+                        "highlight_start": 1,
+                        "text": "($ left : expr, $ right : expr) =>"
+                    },
+                    {
+                        "highlight_end": 3,
+                        "highlight_start": 1,
+                        "text": "({"
+                    },
+                    {
+                        "highlight_end": 33,
+                        "highlight_start": 1,
+                        "text": "     match (& $ left, & $ right)"
+                    },
+                    {
+                        "highlight_end": 7,
+                        "highlight_start": 1,
+                        "text": "     {"
+                    },
+                    {
+                        "highlight_end": 34,
+                        "highlight_start": 1,
+                        "text": "         (left_val, right_val) =>"
+                    },
+                    {
+                        "highlight_end": 11,
+                        "highlight_start": 1,
+                        "text": "         {"
+                    },
+                    {
+                        "highlight_end": 46,
+                        "highlight_start": 1,
+                        "text": "             if ! (* left_val == * right_val)"
+                    },
+                    {
+                        "highlight_end": 15,
+                        "highlight_start": 1,
+                        "text": "             {"
+                    },
+                    {
+                        "highlight_end": 25,
+                        "highlight_start": 1,
+                        "text": "                 panic !"
+                    },
+                    {
+                        "highlight_end": 57,
+                        "highlight_start": 1,
+                        "text": "                 (r#\"assertion failed: `(left == right)`"
+                    },
+                    {
+                        "highlight_end": 16,
+                        "highlight_start": 1,
+                        "text": "  left: `{:?}`,"
+                    },
+                    {
+                        "highlight_end": 18,
+                        "highlight_start": 1,
+                        "text": " right: `{:?}`\"#,"
+                    },
+                    {
+                        "highlight_end": 47,
+                        "highlight_start": 1,
+                        "text": "                  & * left_val, & * right_val)"
+                    },
+                    {
+                        "highlight_end": 15,
+                        "highlight_start": 1,
+                        "text": "             }"
+                    },
+                    {
+                        "highlight_end": 11,
+                        "highlight_start": 1,
+                        "text": "         }"
+                    },
+                    {
+                        "highlight_end": 7,
+                        "highlight_start": 1,
+                        "text": "     }"
+                    },
+                    {
+                        "highlight_end": 42,
+                        "highlight_start": 1,
+                        "text": " }) ; ($ left : expr, $ right : expr,) =>"
+                    },
+                    {
+                        "highlight_end": 49,
+                        "highlight_start": 1,
+                        "text": "({ $ crate :: assert_eq ! ($ left, $ right) }) ;"
+                    },
+                    {
+                        "highlight_end": 53,
+                        "highlight_start": 1,
+                        "text": "($ left : expr, $ right : expr, $ ($ arg : tt) +) =>"
+                    },
+                    {
+                        "highlight_end": 3,
+                        "highlight_start": 1,
+                        "text": "({"
+                    },
+                    {
+                        "highlight_end": 37,
+                        "highlight_start": 1,
+                        "text": "     match (& ($ left), & ($ right))"
+                    },
+                    {
+                        "highlight_end": 7,
+                        "highlight_start": 1,
+                        "text": "     {"
+                    },
+                    {
+                        "highlight_end": 34,
+                        "highlight_start": 1,
+                        "text": "         (left_val, right_val) =>"
+                    },
+                    {
+                        "highlight_end": 11,
+                        "highlight_start": 1,
+                        "text": "         {"
+                    },
+                    {
+                        "highlight_end": 46,
+                        "highlight_start": 1,
+                        "text": "             if ! (* left_val == * right_val)"
+                    },
+                    {
+                        "highlight_end": 15,
+                        "highlight_start": 1,
+                        "text": "             {"
+                    },
+                    {
+                        "highlight_end": 25,
+                        "highlight_start": 1,
+                        "text": "                 panic !"
+                    },
+                    {
+                        "highlight_end": 57,
+                        "highlight_start": 1,
+                        "text": "                 (r#\"assertion failed: `(left == right)`"
+                    },
+                    {
+                        "highlight_end": 16,
+                        "highlight_start": 1,
+                        "text": "  left: `{:?}`,"
+                    },
+                    {
+                        "highlight_end": 22,
+                        "highlight_start": 1,
+                        "text": " right: `{:?}`: {}\"#,"
+                    },
+                    {
+                        "highlight_end": 72,
+                        "highlight_start": 1,
+                        "text": "                  & * left_val, & * right_val, $ crate :: format_args !"
+                    },
+                    {
+                        "highlight_end": 33,
+                        "highlight_start": 1,
+                        "text": "                  ($ ($ arg) +))"
+                    },
+                    {
+                        "highlight_end": 15,
+                        "highlight_start": 1,
+                        "text": "             }"
+                    },
+                    {
+                        "highlight_end": 11,
+                        "highlight_start": 1,
+                        "text": "         }"
+                    },
+                    {
+                        "highlight_end": 7,
+                        "highlight_start": 1,
+                        "text": "     }"
+                    },
+                    {
+                        "highlight_end": 6,
+                        "highlight_start": 1,
+                        "text": " }) ;"
+                    }
+                ]
+            },
+            "macro_decl_name": "assert_eq!",
+            "span": {
+                "byte_end": 38,
+                "byte_start": 16,
+                "column_end": 27,
+                "column_start": 5,
+                "expansion": null,
+                "file_name": "src/main.rs",
+                "is_primary": false,
+                "label": null,
+                "line_end": 2,
+                "line_start": 2,
+                "suggested_replacement": null,
+                "suggestion_applicability": null,
+                "text": [
+                    {
+                        "highlight_end": 27,
+                        "highlight_start": 5,
+                        "text": "    assert_eq!(1, \"love\");"
+                    }
+                ]
+            }
+        },
+        "file_name": "<::core::macros::assert_eq macros>",
+        "is_primary": true,
+        "label": "no implementation for `{integer} == &str`",
+        "line_end": 7,
+        "line_start": 7,
+        "suggested_replacement": null,
+        "suggestion_applicability": null,
+        "text": [
+            {
+                "highlight_end": 33,
+                "highlight_start": 31,
+                "text": "             if ! (* left_val == * right_val)"
+            }
+        ]
+    }
+]
+}"##,
+    );
+    let workspace_root = PathBuf::from("/test/");
+    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root).expect("couldn't map diagnostic");
+    insta::assert_debug_snapshot!(diag);
+}
+#[test]
+fn snap_macro_compiler_error() {
+    let diag = parse_diagnostic(
+        r##"{
+    "rendered": "error: Please register your known path in the path module\n   --> crates/ra_hir_def/src/path.rs:265:9\n    |\n265 |         compile_error!(\"Please register your known path in the path module\")\n    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n    | \n   ::: crates/ra_hir_def/src/data.rs:80:16\n    |\n80  |     let path = path![std::future::Future];\n    |                -------------------------- in this macro invocation\n\n",
+    "children": [],
+    "code": null,
+    "level": "error",
+    "message": "Please register your known path in the path module",
+    "spans": [
+        {
+            "byte_end": 8285,
+            "byte_start": 8217,
+            "column_end": 77,
+            "column_start": 9,
+            "expansion": {
+                "def_site_span": {
+                    "byte_end": 8294,
+                    "byte_start": 7858,
+                    "column_end": 2,
+                    "column_start": 1,
+                    "expansion": null,
+                    "file_name": "crates/ra_hir_def/src/path.rs",
+                    "is_primary": false,
+                    "label": null,
+                    "line_end": 267,
+                    "line_start": 254,
+                    "suggested_replacement": null,
+                    "suggestion_applicability": null,
+                    "text": [
+                        {
+                            "highlight_end": 28,
+                            "highlight_start": 1,
+                            "text": "macro_rules! __known_path {"
+                        },
+                        {
+                            "highlight_end": 37,
+                            "highlight_start": 1,
+                            "text": "    (std::iter::IntoIterator) => {};"
+                        },
+                        {
+                            "highlight_end": 33,
+                            "highlight_start": 1,
+                            "text": "    (std::result::Result) => {};"
+                        },
+                        {
+                            "highlight_end": 29,
+                            "highlight_start": 1,
+                            "text": "    (std::ops::Range) => {};"
+                        },
+                        {
+                            "highlight_end": 33,
+                            "highlight_start": 1,
+                            "text": "    (std::ops::RangeFrom) => {};"
+                        },
+                        {
+                            "highlight_end": 33,
+                            "highlight_start": 1,
+                            "text": "    (std::ops::RangeFull) => {};"
+                        },
+                        {
+                            "highlight_end": 31,
+                            "highlight_start": 1,
+                            "text": "    (std::ops::RangeTo) => {};"
+                        },
+                        {
+                            "highlight_end": 40,
+                            "highlight_start": 1,
+                            "text": "    (std::ops::RangeToInclusive) => {};"
+                        },
+                        {
+                            "highlight_end": 38,
+                            "highlight_start": 1,
+                            "text": "    (std::ops::RangeInclusive) => {};"
+                        },
+                        {
+                            "highlight_end": 27,
+                            "highlight_start": 1,
+                            "text": "    (std::ops::Try) => {};"
+                        },
+                        {
+                            "highlight_end": 22,
+                            "highlight_start": 1,
+                            "text": "    ($path:path) => {"
+                        },
+                        {
+                            "highlight_end": 77,
+                            "highlight_start": 1,
+                            "text": "        compile_error!(\"Please register your known path in the path module\")"
+                        },
+                        {
+                            "highlight_end": 7,
+                            "highlight_start": 1,
+                            "text": "    };"
+                        },
+                        {
+                            "highlight_end": 2,
+                            "highlight_start": 1,
+                            "text": "}"
+                        }
+                    ]
+                },
+                "macro_decl_name": "$crate::__known_path!",
+                "span": {
+                    "byte_end": 8427,
+                    "byte_start": 8385,
+                    "column_end": 51,
+                    "column_start": 9,
+                    "expansion": {
+                        "def_site_span": {
+                            "byte_end": 8611,
+                            "byte_start": 8312,
+                            "column_end": 2,
+                            "column_start": 1,
+                            "expansion": null,
+                            "file_name": "crates/ra_hir_def/src/path.rs",
+                            "is_primary": false,
+                            "label": null,
+                            "line_end": 277,
+                            "line_start": 270,
+                            "suggested_replacement": null,
+                            "suggestion_applicability": null,
+                            "text": [
+                                {
+                                    "highlight_end": 22,
+                                    "highlight_start": 1,
+                                    "text": "macro_rules! __path {"
+                                },
+                                {
+                                    "highlight_end": 43,
+                                    "highlight_start": 1,
+                                    "text": "    ($start:ident $(:: $seg:ident)*) => ({"
+                                },
+                                {
+                                    "highlight_end": 51,
+                                    "highlight_start": 1,
+                                    "text": "        $crate::__known_path!($start $(:: $seg)*);"
+                                },
+                                {
+                                    "highlight_end": 87,
+                                    "highlight_start": 1,
+                                    "text": "        $crate::path::ModPath::from_simple_segments($crate::path::PathKind::Abs, vec!["
+                                },
+                                {
+                                    "highlight_end": 76,
+                                    "highlight_start": 1,
+                                    "text": "            $crate::path::__name![$start], $($crate::path::__name![$seg],)*"
+                                },
+                                {
+                                    "highlight_end": 11,
+                                    "highlight_start": 1,
+                                    "text": "        ])"
+                                },
+                                {
+                                    "highlight_end": 8,
+                                    "highlight_start": 1,
+                                    "text": "    });"
+                                },
+                                {
+                                    "highlight_end": 2,
+                                    "highlight_start": 1,
+                                    "text": "}"
+                                }
+                            ]
+                        },
+                        "macro_decl_name": "path!",
+                        "span": {
+                            "byte_end": 2966,
+                            "byte_start": 2940,
+                            "column_end": 42,
+                            "column_start": 16,
+                            "expansion": null,
+                            "file_name": "crates/ra_hir_def/src/data.rs",
+                            "is_primary": false,
+                            "label": null,
+                            "line_end": 80,
+                            "line_start": 80,
+                            "suggested_replacement": null,
+                            "suggestion_applicability": null,
+                            "text": [
+                                {
+                                    "highlight_end": 42,
+                                    "highlight_start": 16,
+                                    "text": "    let path = path![std::future::Future];"
+                                }
+                            ]
+                        }
+                    },
+                    "file_name": "crates/ra_hir_def/src/path.rs",
+                    "is_primary": false,
+                    "label": null,
+                    "line_end": 272,
+                    "line_start": 272,
+                    "suggested_replacement": null,
+                    "suggestion_applicability": null,
+                    "text": [
+                        {
+                            "highlight_end": 51,
+                            "highlight_start": 9,
+                            "text": "        $crate::__known_path!($start $(:: $seg)*);"
+                        }
+                    ]
+                }
+            },
+            "file_name": "crates/ra_hir_def/src/path.rs",
+            "is_primary": true,
+            "label": null,
+            "line_end": 265,
+            "line_start": 265,
+            "suggested_replacement": null,
+            "suggestion_applicability": null,
+            "text": [
+                {
+                    "highlight_end": 77,
+                    "highlight_start": 9,
+                    "text": "        compile_error!(\"Please register your known path in the path module\")"
+                }
+            ]
+        }
+    ]
+}
+        "##,
+    );
+    let workspace_root = PathBuf::from("/test/");
+    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root).expect("couldn't map diagnostic");
+    insta::assert_debug_snapshot!(diag);
+}
diff --git a/crates/ra_cargo_watch/src/lib.rs b/crates/ra_cargo_watch/src/lib.rs
new file mode 100644
index 000000000..9bc0fd405
--- /dev/null
+++ b/crates/ra_cargo_watch/src/lib.rs
@@ -0,0 +1,394 @@
+//! cargo_check provides the functionality needed to run `cargo check` or
+//! another compatible command (f.x. clippy) in a background thread and provide
+//! LSP diagnostics based on the output of the command.
+use cargo_metadata::Message;
+use crossbeam_channel::{never, select, unbounded, Receiver, RecvError, Sender};
+use lsp_types::{
+    Diagnostic, Url, WorkDoneProgress, WorkDoneProgressBegin, WorkDoneProgressEnd,
+    WorkDoneProgressReport,
+};
+use parking_lot::RwLock;
+use std::{
+    collections::HashMap,
+    path::PathBuf,
+    process::{Command, Stdio},
+    sync::Arc,
+    thread::JoinHandle,
+    time::Instant,
+};
+mod conv;
+use crate::conv::{map_rust_diagnostic_to_lsp, MappedRustDiagnostic, SuggestedFix};
+pub use crate::conv::url_from_path_with_drive_lowercasing;
+#[derive(Clone, Debug)]
+pub struct CheckOptions {
+    pub enable: bool,
+    pub args: Vec<String>,
+    pub command: String,
+    pub all_targets: bool,
+}
+/// CheckWatcher wraps the shared state and communication machinery used for
+/// running `cargo check` (or other compatible command) and providing
+/// diagnostics based on the output.
+/// The spawned thread is shut down when this struct is dropped.
+#[derive(Debug)]
+pub struct CheckWatcher {
+    pub task_recv: Receiver<CheckTask>,
+    pub shared: Arc<RwLock<CheckWatcherSharedState>>,
+    cmd_send: Option<Sender<CheckCommand>>,
+    handle: Option<JoinHandle<()>>,
+}
+impl CheckWatcher {
+    pub fn new(options: &CheckOptions, workspace_root: PathBuf) -> CheckWatcher {
+        let options = options.clone();
+        let shared = Arc::new(RwLock::new(CheckWatcherSharedState::new()));
+        let (task_send, task_recv) = unbounded::<CheckTask>();
+        let (cmd_send, cmd_recv) = unbounded::<CheckCommand>();
+        let shared_ = shared.clone();
+        let handle = std::thread::spawn(move || {
+            let mut check = CheckWatcherState::new(options, workspace_root, shared_);
+            check.run(&task_send, &cmd_recv);
+        });
+        CheckWatcher { task_recv, cmd_send: Some(cmd_send), handle: Some(handle), shared }
+    }
+    /// Schedule a re-start of the cargo check worker.
+    pub fn update(&self) {
+        if let Some(cmd_send) = &self.cmd_send {
+            cmd_send.send(CheckCommand::Update).unwrap();
+        }
+    }
+}
+impl std::ops::Drop for CheckWatcher {
+    fn drop(&mut self) {
+        if let Some(handle) = self.handle.take() {
+            // Take the sender out of the option
+            let recv = self.cmd_send.take();
+            // Dropping the sender finishes the thread loop
+            drop(recv);
+            // Join the thread, it should finish shortly. We don't really care
+            // whether it panicked, so it is safe to ignore the result
+            let _ = handle.join();
+        }
+    }
+}
+#[derive(Debug)]
+pub struct CheckWatcherSharedState {
+    diagnostic_collection: HashMap<Url, Vec<Diagnostic>>,
+    suggested_fix_collection: HashMap<Url, Vec<SuggestedFix>>,
+}
+impl CheckWatcherSharedState {
+    fn new() -> CheckWatcherSharedState {
+        CheckWatcherSharedState {
+            diagnostic_collection: HashMap::new(),
+            suggested_fix_collection: HashMap::new(),
+        }
+    }
+    /// Clear the cached diagnostics, and schedule updating diagnostics by the
+    /// server, to clear stale results.
+    pub fn clear(&mut self, task_send: &Sender<CheckTask>) {
+        let cleared_files: Vec<Url> = self.diagnostic_collection.keys().cloned().collect();
+        self.diagnostic_collection.clear();
+        self.suggested_fix_collection.clear();
+        for uri in cleared_files {
+            task_send.send(CheckTask::Update(uri.clone())).unwrap();
+        }
+    }
+    pub fn diagnostics_for(&self, uri: &Url) -> Option<&[Diagnostic]> {
+        self.diagnostic_collection.get(uri).map(|d| d.as_slice())
+    }
+    pub fn fixes_for(&self, uri: &Url) -> Option<&[SuggestedFix]> {
+        self.suggested_fix_collection.get(uri).map(|d| d.as_slice())
+    }
+    fn add_diagnostic(&mut self, file_uri: Url, diagnostic: Diagnostic) {
+        let diagnostics = self.diagnostic_collection.entry(file_uri).or_default();
+        // If we're building multiple targets it's possible we've already seen this diagnostic
+        let is_duplicate = diagnostics.iter().any(|d| are_diagnostics_equal(d, &diagnostic));
+        if is_duplicate {
+            return;
+        }
+        diagnostics.push(diagnostic);
+    }
+    fn add_suggested_fix_for_diagnostic(
+        &mut self,
+        mut suggested_fix: SuggestedFix,
+        diagnostic: &Diagnostic,
+    ) {
+        let file_uri = suggested_fix.location.uri.clone();
+        let file_suggestions = self.suggested_fix_collection.entry(file_uri).or_default();
+        let existing_suggestion: Option<&mut SuggestedFix> =
+            file_suggestions.iter_mut().find(|s| s == &&suggested_fix);
+        if let Some(existing_suggestion) = existing_suggestion {
+            // The existing suggestion also applies to this new diagnostic
+            existing_suggestion.diagnostics.push(diagnostic.clone());
+        } else {
+            // We haven't seen this suggestion before
+            suggested_fix.diagnostics.push(diagnostic.clone());
+            file_suggestions.push(suggested_fix);
+        }
+    }
+}
+#[derive(Debug)]
+pub enum CheckTask {
+    /// Request a update of the given files diagnostics
+    Update(Url),
+    /// Request check progress notification to client
+    Status(WorkDoneProgress),
+}
+pub enum CheckCommand {
+    /// Request re-start of check thread
+    Update,
+}
+struct CheckWatcherState {
+    options: CheckOptions,
+    workspace_root: PathBuf,
+    watcher: WatchThread,
+    last_update_req: Option<Instant>,
+    shared: Arc<RwLock<CheckWatcherSharedState>>,
+}
+impl CheckWatcherState {
+    fn new(
+        options: CheckOptions,
+        workspace_root: PathBuf,
+        shared: Arc<RwLock<CheckWatcherSharedState>>,
+    ) -> CheckWatcherState {
+        let watcher = WatchThread::new(&options, &workspace_root);
+        CheckWatcherState { options, workspace_root, watcher, last_update_req: None, shared }
+    }
+    fn run(&mut self, task_send: &Sender<CheckTask>, cmd_recv: &Receiver<CheckCommand>) {
+        loop {
+            select! {
+                recv(&cmd_recv) -> cmd => match cmd {
+                    Ok(cmd) => self.handle_command(cmd),
+                    Err(RecvError) => {
+                        // Command channel has closed, so shut down
+                        break;
+                    },
+                },
+                recv(self.watcher.message_recv) -> msg => match msg {
+                    Ok(msg) => self.handle_message(msg, task_send),
+                    Err(RecvError) => {
+                        // Watcher finished, replace it with a never channel to
+                        // avoid busy-waiting.
+                        std::mem::replace(&mut self.watcher.message_recv, never());
+                    },
+                }
+            };
+            if self.should_recheck() {
+                self.last_update_req.take();
+                self.shared.write().clear(task_send);
+                // By replacing the watcher, we drop the previous one which
+                // causes it to shut down automatically.
+                self.watcher = WatchThread::new(&self.options, &self.workspace_root);
+            }
+        }
+    }
+    fn should_recheck(&mut self) -> bool {
+        if let Some(_last_update_req) = &self.last_update_req {
+            // We currently only request an update on save, as we need up to
+            // date source on disk for cargo check to do it's magic, so we
+            // don't really need to debounce the requests at this point.
+            return true;
+        }
+        false
+    }
+    fn handle_command(&mut self, cmd: CheckCommand) {
+        match cmd {
+            CheckCommand::Update => self.last_update_req = Some(Instant::now()),
+        }
+    }
+    fn handle_message(&mut self, msg: CheckEvent, task_send: &Sender<CheckTask>) {
+        match msg {
+            CheckEvent::Begin => {
+                task_send
+                    .send(CheckTask::Status(WorkDoneProgress::Begin(WorkDoneProgressBegin {
+                        title: "Running 'cargo check'".to_string(),
+                        cancellable: Some(false),
+                        message: None,
+                        percentage: None,
+                    })))
+                    .unwrap();
+            }
+            CheckEvent::End => {
+                task_send
+                    .send(CheckTask::Status(WorkDoneProgress::End(WorkDoneProgressEnd {
+                        message: None,
+                    })))
+                    .unwrap();
+            }
+            CheckEvent::Msg(Message::CompilerArtifact(msg)) => {
+                task_send
+                    .send(CheckTask::Status(WorkDoneProgress::Report(WorkDoneProgressReport {
+                        cancellable: Some(false),
+                        message: Some(msg.target.name),
+                        percentage: None,
+                    })))
+                    .unwrap();
+            }
+            CheckEvent::Msg(Message::CompilerMessage(msg)) => {
+                let map_result =
+                    match map_rust_diagnostic_to_lsp(&msg.message, &self.workspace_root) {
+                        Some(map_result) => map_result,
+                        None => return,
+                    };
+                let MappedRustDiagnostic { location, diagnostic, suggested_fixes } = map_result;
+                let file_uri = location.uri.clone();
+                if !suggested_fixes.is_empty() {
+                    for suggested_fix in suggested_fixes {
+                        self.shared
+                            .write()
+                            .add_suggested_fix_for_diagnostic(suggested_fix, &diagnostic);
+                    }
+                }
+                self.shared.write().add_diagnostic(file_uri, diagnostic);
+                task_send.send(CheckTask::Update(location.uri)).unwrap();
+            }
+            CheckEvent::Msg(Message::BuildScriptExecuted(_msg)) => {}
+            CheckEvent::Msg(Message::Unknown) => {}
+        }
+    }
+}
+/// WatchThread exists to wrap around the communication needed to be able to
+/// run `cargo check` without blocking. Currently the Rust standard library
+/// doesn't provide a way to read sub-process output without blocking, so we
+/// have to wrap sub-processes output handling in a thread and pass messages
+/// back over a channel.
+/// The correct way to dispose of the thread is to drop it, on which the
+/// sub-process will be killed, and the thread will be joined.
+struct WatchThread {
+    handle: Option<JoinHandle<()>>,
+    message_recv: Receiver<CheckEvent>,
+}
+enum CheckEvent {
+    Begin,
+    Msg(cargo_metadata::Message),
+    End,
+}
+impl WatchThread {
+    fn new(options: &CheckOptions, workspace_root: &PathBuf) -> WatchThread {
+        let mut args: Vec<String> = vec![
+            options.command.clone(),
+            "--message-format=json".to_string(),
+            "--manifest-path".to_string(),
+            format!("{}/Cargo.toml", workspace_root.to_string_lossy()),
+        ];
+        if options.all_targets {
+            args.push("--all-targets".to_string());
+        }
+        args.extend(options.args.iter().cloned());
+        let (message_send, message_recv) = unbounded();
+        let enabled = options.enable;
+        let handle = std::thread::spawn(move || {
+            if !enabled {
+                return;
+            }
+            let mut command = Command::new("cargo")
+                .args(&args)
+                .stdout(Stdio::piped())
+                .stderr(Stdio::null())
+                .spawn()
+                .expect("couldn't launch cargo");
+            // If we trigger an error here, we will do so in the loop instead,
+            // which will break out of the loop, and continue the shutdown
+            let _ = message_send.send(CheckEvent::Begin);
+            for message in cargo_metadata::parse_messages(command.stdout.take().unwrap()) {
+                let message = match message {
+                    Ok(message) => message,
+                    Err(err) => {
+                        log::error!("Invalid json from cargo check, ignoring: {}", err);
+                        continue;
+                    }
+                };
+                match message_send.send(CheckEvent::Msg(message)) {
+                    Ok(()) => {}
+                    Err(_err) => {
+                        // The send channel was closed, so we want to shutdown
+                        break;
+                    }
+                }
+            }
+            // We can ignore any error here, as we are already in the progress
+            // of shutting down.
+            let _ = message_send.send(CheckEvent::End);
+            // It is okay to ignore the result, as it only errors if the process is already dead
+            let _ = command.kill();
+            // Again, we don't care about the exit status so just ignore the result
+            let _ = command.wait();
+        });
+        WatchThread { handle: Some(handle), message_recv }
+    }
+}
+impl std::ops::Drop for WatchThread {
+    fn drop(&mut self) {
+        if let Some(handle) = self.handle.take() {
+            // Replace our reciever with dummy one, so we can drop and close the
+            // one actually communicating with the thread
+            let recv = std::mem::replace(&mut self.message_recv, never());
+            // Dropping the original reciever initiates thread sub-process shutdown
+            drop(recv);
+            // Join the thread, it should finish shortly. We don't really care
+            // whether it panicked, so it is safe to ignore the result
+            let _ = handle.join();
+        }
+    }
+}
+fn are_diagnostics_equal(left: &Diagnostic, right: &Diagnostic) -> bool {
+    left.source == right.source
+        && left.severity == right.severity
+        && left.range == right.range
+        && left.message == right.message
+}
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 76d8f85f1..488f74cfb 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -118,7 +118,7 @@ impl_froms!(
    BuiltinType
 );
-pub use hir_def::attr::Attrs;
+pub use hir_def::{attr::Attrs, visibility::Visibility};
 impl Module {
    pub(crate) fn new(krate: Crate, crate_module_id: LocalModuleId) -> Module {
@@ -255,6 +255,15 @@ impl StructField {
    }
 }
+impl HasVisibility for StructField {
+    fn visibility(&self, db: &impl HirDatabase) -> Visibility {
+        let variant_data = self.parent.variant_data(db);
+        let visibility = &variant_data.fields()[self.id].visibility;
+        let parent_id: hir_def::VariantId = self.parent.into();
+        visibility.resolve(db, &parent_id.resolver(db))
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Struct {
    pub(crate) id: StructId,
@@ -1041,3 +1050,11 @@ impl<T: Into<AttrDef> + Copy> Docs for T {
        db.documentation(def.into())
    }
 }
+pub trait HasVisibility {
+    fn visibility(&self, db: &impl HirDatabase) -> Visibility;
+    fn is_visible_from(&self, db: &impl HirDatabase, module: Module) -> bool {
+        let vis = self.visibility(db);
+        vis.is_visible_from(db, module.id)
+    }
+}
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 0008a8858..3d13978d4 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -40,8 +40,8 @@ mod from_source;
 pub use crate::{
    code_model::{
        Adt, AssocItem, AttrDef, Const, Crate, CrateDependency, DefWithBody, Docs, Enum,
-        EnumVariant, FieldSource, Function, GenericDef, HasAttrs, ImplBlock, Local, MacroDef,
+        EnumVariant, FieldSource, Function, GenericDef, HasAttrs, HasVisibility, ImplBlock, Local,
-        Module, ModuleDef, ScopeDef, Static, Struct, StructField, Trait, Type, TypeAlias,
+        MacroDef, Module, ModuleDef, ScopeDef, Static, Struct, StructField, Trait, Type, TypeAlias,
        TypeParam, Union, VariantDef,
    },
    from_source::FromSource,
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index 85b378483..2c422af8b 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -215,8 +215,32 @@ impl SourceAnalyzer {
        self.body_source_map.as_ref()?.node_pat(src)
    }
+    fn expand_expr(
+        &self,
+        db: &impl HirDatabase,
+        expr: InFile<&ast::Expr>,
+    ) -> Option<InFile<ast::Expr>> {
+        let macro_call = ast::MacroCall::cast(expr.value.syntax().clone())?;
+        let macro_file =
+            self.body_source_map.as_ref()?.node_macro_file(expr.with_value(&macro_call))?;
+        let expanded = db.parse_or_expand(macro_file)?;
+        let kind = expanded.kind();
+        let expr = InFile::new(macro_file, ast::Expr::cast(expanded)?);
+        if ast::MacroCall::can_cast(kind) {
+            self.expand_expr(db, expr.as_ref())
+        } else {
+            Some(expr)
+        }
+    }
    pub fn type_of(&self, db: &impl HirDatabase, expr: &ast::Expr) -> Option<Type> {
-        let expr_id = self.expr_id(expr)?;
+        let expr_id = if let Some(expr) = self.expand_expr(db, InFile::new(self.file_id, expr)) {
+            self.body_source_map.as_ref()?.node_expr(expr.as_ref())?
+        } else {
+            self.expr_id(expr)?
+        };
        let ty = self.infer.as_ref()?[expr_id].clone();
        let environment = TraitEnvironment::lower(db, &self.resolver);
        Some(Type { krate: self.resolver.krate()?, ty: InEnvironment { value: ty, environment } })
diff --git a/crates/ra_hir_def/src/adt.rs b/crates/ra_hir_def/src/adt.rs
index d9ea693e3..aac5f3e15 100644
--- a/crates/ra_hir_def/src/adt.rs
+++ b/crates/ra_hir_def/src/adt.rs
@@ -9,11 +9,12 @@ use hir_expand::{
 };
 use ra_arena::{map::ArenaMap, Arena};
 use ra_prof::profile;
-use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner};
+use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner, VisibilityOwner};
 use crate::{
-    db::DefDatabase, src::HasChildSource, src::HasSource, trace::Trace, type_ref::TypeRef, EnumId,
+    db::DefDatabase, src::HasChildSource, src::HasSource, trace::Trace, type_ref::TypeRef,
-    LocalEnumVariantId, LocalStructFieldId, Lookup, StructId, UnionId, VariantId,
+    visibility::RawVisibility, EnumId, LocalEnumVariantId, LocalStructFieldId, Lookup, StructId,
+    UnionId, VariantId,
 };
 /// Note that we use `StructData` for unions as well!
@@ -47,13 +48,14 @@ pub enum VariantData {
 pub struct StructFieldData {
    pub name: Name,
    pub type_ref: TypeRef,
+    pub visibility: RawVisibility,
 }
 impl StructData {
    pub(crate) fn struct_data_query(db: &impl DefDatabase, id: StructId) -> Arc<StructData> {
        let src = id.lookup(db).source(db);
        let name = src.value.name().map_or_else(Name::missing, |n| n.as_name());
-        let variant_data = VariantData::new(src.value.kind());
+        let variant_data = VariantData::new(db, src.map(|s| s.kind()));
        let variant_data = Arc::new(variant_data);
        Arc::new(StructData { name, variant_data })
    }
@@ -61,10 +63,12 @@ impl StructData {
        let src = id.lookup(db).source(db);
        let name = src.value.name().map_or_else(Name::missing, |n| n.as_name());
        let variant_data = VariantData::new(
-            src.value
+            db,
-                .record_field_def_list()
+            src.map(|s| {
-                .map(ast::StructKind::Record)
+                s.record_field_def_list()
-                .unwrap_or(ast::StructKind::Unit),
+                    .map(ast::StructKind::Record)
+                    .unwrap_or(ast::StructKind::Unit)
+            }),
        );
        let variant_data = Arc::new(variant_data);
        Arc::new(StructData { name, variant_data })
@@ -77,7 +81,7 @@ impl EnumData {
        let src = e.lookup(db).source(db);
        let name = src.value.name().map_or_else(Name::missing, |n| n.as_name());
        let mut trace = Trace::new_for_arena();
-        lower_enum(&mut trace, &src.value);
+        lower_enum(db, &mut trace, &src);
        Arc::new(EnumData { name, variants: trace.into_arena() })
    }
@@ -93,30 +97,31 @@ impl HasChildSource for EnumId {
    fn child_source(&self, db: &impl DefDatabase) -> InFile<ArenaMap<Self::ChildId, Self::Value>> {
        let src = self.lookup(db).source(db);
        let mut trace = Trace::new_for_map();
-        lower_enum(&mut trace, &src.value);
+        lower_enum(db, &mut trace, &src);
        src.with_value(trace.into_map())
    }
 }
 fn lower_enum(
+    db: &impl DefDatabase,
    trace: &mut Trace<LocalEnumVariantId, EnumVariantData, ast::EnumVariant>,
-    ast: &ast::EnumDef,
+    ast: &InFile<ast::EnumDef>,
 ) {
-    for var in ast.variant_list().into_iter().flat_map(|it| it.variants()) {
+    for var in ast.value.variant_list().into_iter().flat_map(|it| it.variants()) {
        trace.alloc(
            || var.clone(),
            || EnumVariantData {
                name: var.name().map_or_else(Name::missing, |it| it.as_name()),
-                variant_data: Arc::new(VariantData::new(var.kind())),
+                variant_data: Arc::new(VariantData::new(db, ast.with_value(var.kind()))),
            },
        );
    }
 }
 impl VariantData {
-    fn new(flavor: ast::StructKind) -> Self {
+    fn new(db: &impl DefDatabase, flavor: InFile<ast::StructKind>) -> Self {
        let mut trace = Trace::new_for_arena();
-        match lower_struct(&mut trace, &flavor) {
+        match lower_struct(db, &mut trace, &flavor) {
            StructKind::Tuple => VariantData::Tuple(trace.into_arena()),
            StructKind::Record => VariantData::Record(trace.into_arena()),
            StructKind::Unit => VariantData::Unit,
@@ -163,7 +168,7 @@ impl HasChildSource for VariantId {
            }),
        };
        let mut trace = Trace::new_for_map();
-        lower_struct(&mut trace, &src.value);
+        lower_struct(db, &mut trace, &src);
        src.with_value(trace.into_map())
    }
 }
@@ -175,14 +180,15 @@ enum StructKind {
 }
 fn lower_struct(
+    db: &impl DefDatabase,
    trace: &mut Trace<
        LocalStructFieldId,
        StructFieldData,
        Either<ast::TupleFieldDef, ast::RecordFieldDef>,
    >,
-    ast: &ast::StructKind,
+    ast: &InFile<ast::StructKind>,
 ) -> StructKind {
-    match ast {
+    match &ast.value {
        ast::StructKind::Tuple(fl) => {
            for (i, fd) in fl.fields().enumerate() {
                trace.alloc(
@@ -190,6 +196,7 @@ fn lower_struct(
                    || StructFieldData {
                        name: Name::new_tuple_field(i),
                        type_ref: TypeRef::from_ast_opt(fd.type_ref()),
+                        visibility: RawVisibility::from_ast(db, ast.with_value(fd.visibility())),
                    },
                );
            }
@@ -202,6 +209,7 @@ fn lower_struct(
                    || StructFieldData {
                        name: fd.name().map(|n| n.as_name()).unwrap_or_else(Name::missing),
                        type_ref: TypeRef::from_ast_opt(fd.ascribed_type()),
+                        visibility: RawVisibility::from_ast(db, ast.with_value(fd.visibility())),
                    },
                );
            }
diff --git a/crates/ra_hir_def/src/body.rs b/crates/ra_hir_def/src/body.rs
index d3e4c50ae..142c52d35 100644
--- a/crates/ra_hir_def/src/body.rs
+++ b/crates/ra_hir_def/src/body.rs
@@ -163,6 +163,7 @@ pub struct BodySourceMap {
    pat_map: FxHashMap<PatSource, PatId>,
    pat_map_back: ArenaMap<PatId, PatSource>,
    field_map: FxHashMap<(ExprId, usize), AstPtr<ast::RecordField>>,
+    expansions: FxHashMap<InFile<AstPtr<ast::MacroCall>>, HirFileId>,
 }
 impl Body {
@@ -237,6 +238,11 @@ impl BodySourceMap {
        self.expr_map.get(&src).cloned()
    }
+    pub fn node_macro_file(&self, node: InFile<&ast::MacroCall>) -> Option<HirFileId> {
+        let src = node.map(|it| AstPtr::new(it));
+        self.expansions.get(&src).cloned()
+    }
    pub fn field_init_shorthand_expr(&self, node: InFile<&ast::RecordField>) -> Option<ExprId> {
        let src = node.map(|it| Either::Right(AstPtr::new(it)));
        self.expr_map.get(&src).cloned()
diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
index 5323af097..e656f9a41 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -446,14 +446,20 @@ where
                }
            }
            // FIXME expand to statements in statement position
-            ast::Expr::MacroCall(e) => match self.expander.enter_expand(self.db, e) {
+            ast::Expr::MacroCall(e) => {
-                Some((mark, expansion)) => {
+                let macro_call = self.expander.to_source(AstPtr::new(&e));
-                    let id = self.collect_expr(expansion);
+                match self.expander.enter_expand(self.db, e.clone()) {
-                    self.expander.exit(self.db, mark);
+                    Some((mark, expansion)) => {
-                    id
+                        self.source_map
+                            .expansions
+                            .insert(macro_call, self.expander.current_file_id);
+                        let id = self.collect_expr(expansion);
+                        self.expander.exit(self.db, mark);
+                        id
+                    }
+                    None => self.alloc_expr(Expr::Missing, syntax_ptr),
                }
-                None => self.alloc_expr(Expr::Missing, syntax_ptr),
+            }
-            },
            // FIXME implement HIR for these:
            ast::Expr::Label(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
@@ -543,7 +549,10 @@ where
            };
            self.body.item_scope.define_def(def);
            if let Some(name) = name {
-                self.body.item_scope.push_res(name.as_name(), def.into());
+                let vis = crate::visibility::Visibility::Public; // FIXME determine correctly
+                self.body
+                    .item_scope
+                    .push_res(name.as_name(), crate::per_ns::PerNs::from_def(def, vis));
            }
        }
    }
diff --git a/crates/ra_hir_def/src/item_scope.rs b/crates/ra_hir_def/src/item_scope.rs
index b0288ee8d..fe7bb9779 100644
--- a/crates/ra_hir_def/src/item_scope.rs
+++ b/crates/ra_hir_def/src/item_scope.rs
@@ -5,7 +5,10 @@ use hir_expand::name::Name;
 use once_cell::sync::Lazy;
 use rustc_hash::FxHashMap;
-use crate::{per_ns::PerNs, AdtId, BuiltinType, ImplId, MacroDefId, ModuleDefId, TraitId};
+use crate::{
+    per_ns::PerNs, visibility::Visibility, AdtId, BuiltinType, ImplId, MacroDefId, ModuleDefId,
+    TraitId,
+};
 #[derive(Debug, Default, PartialEq, Eq)]
 pub struct ItemScope {
@@ -30,7 +33,7 @@ pub struct ItemScope {
 static BUILTIN_SCOPE: Lazy<FxHashMap<Name, PerNs>> = Lazy::new(|| {
    BuiltinType::ALL
        .iter()
-        .map(|(name, ty)| (name.clone(), PerNs::types(ty.clone().into())))
+        .map(|(name, ty)| (name.clone(), PerNs::types(ty.clone().into(), Visibility::Public)))
        .collect()
 });
@@ -144,8 +147,8 @@ impl ItemScope {
        changed
    }
-    pub(crate) fn collect_resolutions(&self) -> Vec<(Name, PerNs)> {
+    pub(crate) fn resolutions<'a>(&'a self) -> impl Iterator<Item = (Name, PerNs)> + 'a {
-        self.visible.iter().map(|(name, res)| (name.clone(), res.clone())).collect()
+        self.visible.iter().map(|(name, res)| (name.clone(), res.clone()))
    }
    pub(crate) fn collect_legacy_macros(&self) -> FxHashMap<Name, MacroDefId> {
@@ -153,20 +156,20 @@ impl ItemScope {
    }
 }
-impl From<ModuleDefId> for PerNs {
+impl PerNs {
-    fn from(def: ModuleDefId) -> PerNs {
+    pub(crate) fn from_def(def: ModuleDefId, v: Visibility) -> PerNs {
        match def {
-            ModuleDefId::ModuleId(_) => PerNs::types(def),
+            ModuleDefId::ModuleId(_) => PerNs::types(def, v),
-            ModuleDefId::FunctionId(_) => PerNs::values(def),
+            ModuleDefId::FunctionId(_) => PerNs::values(def, v),
            ModuleDefId::AdtId(adt) => match adt {
-                AdtId::StructId(_) | AdtId::UnionId(_) => PerNs::both(def, def),
+                AdtId::StructId(_) | AdtId::UnionId(_) => PerNs::both(def, def, v),
-                AdtId::EnumId(_) => PerNs::types(def),
+                AdtId::EnumId(_) => PerNs::types(def, v),
            },
-            ModuleDefId::EnumVariantId(_) => PerNs::both(def, def),
+            ModuleDefId::EnumVariantId(_) => PerNs::both(def, def, v),
-            ModuleDefId::ConstId(_) | ModuleDefId::StaticId(_) => PerNs::values(def),
+            ModuleDefId::ConstId(_) | ModuleDefId::StaticId(_) => PerNs::values(def, v),
-            ModuleDefId::TraitId(_) => PerNs::types(def),
+            ModuleDefId::TraitId(_) => PerNs::types(def, v),
-            ModuleDefId::TypeAliasId(_) => PerNs::types(def),
+            ModuleDefId::TypeAliasId(_) => PerNs::types(def, v),
-            ModuleDefId::BuiltinType(_) => PerNs::types(def),
+            ModuleDefId::BuiltinType(_) => PerNs::types(def, v),
        }
    }
 }
diff --git a/crates/ra_hir_def/src/lang_item.rs b/crates/ra_hir_def/src/lang_item.rs
index cef061837..37c861a87 100644
--- a/crates/ra_hir_def/src/lang_item.rs
+++ b/crates/ra_hir_def/src/lang_item.rs
@@ -22,6 +22,50 @@ pub enum LangItemTarget {
    TraitId(TraitId),
 }
+impl LangItemTarget {
+    pub fn as_enum(self) -> Option<EnumId> {
+        match self {
+            LangItemTarget::EnumId(id) => Some(id),
+            _ => None,
+        }
+    }
+    pub fn as_function(self) -> Option<FunctionId> {
+        match self {
+            LangItemTarget::FunctionId(id) => Some(id),
+            _ => None,
+        }
+    }
+    pub fn as_impl_block(self) -> Option<ImplId> {
+        match self {
+            LangItemTarget::ImplBlockId(id) => Some(id),
+            _ => None,
+        }
+    }
+    pub fn as_static(self) -> Option<StaticId> {
+        match self {
+            LangItemTarget::StaticId(id) => Some(id),
+            _ => None,
+        }
+    }
+    pub fn as_struct(self) -> Option<StructId> {
+        match self {
+            LangItemTarget::StructId(id) => Some(id),
+            _ => None,
+        }
+    }
+    pub fn as_trait(self) -> Option<TraitId> {
+        match self {
+            LangItemTarget::TraitId(id) => Some(id),
+            _ => None,
+        }
+    }
+}
 #[derive(Default, Debug, Clone, PartialEq, Eq)]
 pub struct LangItems {
    items: FxHashMap<SmolStr, LangItemTarget>,
diff --git a/crates/ra_hir_def/src/lib.rs b/crates/ra_hir_def/src/lib.rs
index f6c7f38d1..61f044ecf 100644
--- a/crates/ra_hir_def/src/lib.rs
+++ b/crates/ra_hir_def/src/lib.rs
@@ -36,6 +36,8 @@ pub mod nameres;
 pub mod src;
 pub mod child_by_source;
+pub mod visibility;
 #[cfg(test)]
 mod test_db;
 #[cfg(test)]
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index b9f40d3dd..8a22b0585 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -24,6 +24,7 @@ use crate::{
    },
    path::{ModPath, PathKind},
    per_ns::PerNs,
+    visibility::Visibility,
    AdtId, AstId, ConstLoc, ContainerId, EnumLoc, EnumVariantId, FunctionLoc, ImplLoc, Intern,
    LocalModuleId, ModuleDefId, ModuleId, StaticLoc, StructLoc, TraitLoc, TypeAliasLoc, UnionLoc,
 };
@@ -108,7 +109,7 @@ struct MacroDirective {
 struct DefCollector<'a, DB> {
    db: &'a DB,
    def_map: CrateDefMap,
-    glob_imports: FxHashMap<LocalModuleId, Vec<(LocalModuleId, raw::Import)>>,
+    glob_imports: FxHashMap<LocalModuleId, Vec<(LocalModuleId, Visibility)>>,
    unresolved_imports: Vec<ImportDirective>,
    resolved_imports: Vec<ImportDirective>,
    unexpanded_macros: Vec<MacroDirective>,
@@ -214,7 +215,11 @@ where
        // In Rust, `#[macro_export]` macros are unconditionally visible at the
        // crate root, even if the parent modules is **not** visible.
        if export {
-            self.update(self.def_map.root, &[(name, PerNs::macros(macro_))]);
+            self.update(
+                self.def_map.root,
+                &[(name, PerNs::macros(macro_, Visibility::Public))],
+                Visibility::Public,
+            );
        }
    }
@@ -348,9 +353,12 @@ where
    fn record_resolved_import(&mut self, directive: &ImportDirective) {
        let module_id = directive.module_id;
-        let import_id = directive.import_id;
        let import = &directive.import;
        let def = directive.status.namespaces();
+        let vis = self
+            .def_map
+            .resolve_visibility(self.db, module_id, &directive.import.visibility)
+            .unwrap_or(Visibility::Public);
        if import.is_glob {
            log::debug!("glob import: {:?}", import);
@@ -366,9 +374,16 @@ where
                        let scope = &item_map[m.local_id].scope;
                        // Module scoped macros is included
-                        let items = scope.collect_resolutions();
+                        let items = scope
+                            .resolutions()
-                        self.update(module_id, &items);
+                            // only keep visible names...
+                            .map(|(n, res)| {
+                                (n, res.filter_visibility(|v| v.is_visible_from_other_crate()))
+                            })
+                            .filter(|(_, res)| !res.is_none())
+                            .collect::<Vec<_>>();
+                        self.update(module_id, &items, vis);
                    } else {
                        // glob import from same crate => we do an initial
                        // import, and then need to propagate any further
@@ -376,13 +391,25 @@ where
                        let scope = &self.def_map[m.local_id].scope;
                        // Module scoped macros is included
-                        let items = scope.collect_resolutions();
+                        let items = scope
+                            .resolutions()
-                        self.update(module_id, &items);
+                            // only keep visible names...
+                            .map(|(n, res)| {
+                                (
+                                    n,
+                                    res.filter_visibility(|v| {
+                                        v.is_visible_from_def_map(&self.def_map, module_id)
+                                    }),
+                                )
+                            })
+                            .filter(|(_, res)| !res.is_none())
+                            .collect::<Vec<_>>();
+                        self.update(module_id, &items, vis);
                        // record the glob import in case we add further items
                        let glob = self.glob_imports.entry(m.local_id).or_default();
-                        if !glob.iter().any(|it| *it == (module_id, import_id)) {
+                        if !glob.iter().any(|(mid, _)| *mid == module_id) {
-                            glob.push((module_id, import_id));
+                            glob.push((module_id, vis));
                        }
                    }
                }
@@ -396,11 +423,11 @@ where
                        .map(|(local_id, variant_data)| {
                            let name = variant_data.name.clone();
                            let variant = EnumVariantId { parent: e, local_id };
-                            let res = PerNs::both(variant.into(), variant.into());
+                            let res = PerNs::both(variant.into(), variant.into(), vis);
                            (name, res)
                        })
                        .collect::<Vec<_>>();
-                    self.update(module_id, &resolutions);
+                    self.update(module_id, &resolutions, vis);
                }
                Some(d) => {
                    log::debug!("glob import {:?} from non-module/enum {:?}", import, d);
@@ -422,21 +449,24 @@ where
                        }
                    }
-                    self.update(module_id, &[(name, def)]);
+                    self.update(module_id, &[(name, def)], vis);
                }
                None => tested_by!(bogus_paths),
            }
        }
    }
-    fn update(&mut self, module_id: LocalModuleId, resolutions: &[(Name, PerNs)]) {
+    fn update(&mut self, module_id: LocalModuleId, resolutions: &[(Name, PerNs)], vis: Visibility) {
-        self.update_recursive(module_id, resolutions, 0)
+        self.update_recursive(module_id, resolutions, vis, 0)
    }
    fn update_recursive(
        &mut self,
        module_id: LocalModuleId,
        resolutions: &[(Name, PerNs)],
+        // All resolutions are imported with this visibility; the visibilies in
+        // the `PerNs` values are ignored and overwritten
+        vis: Visibility,
        depth: usize,
    ) {
        if depth > 100 {
@@ -446,7 +476,7 @@ where
        let scope = &mut self.def_map.modules[module_id].scope;
        let mut changed = false;
        for (name, res) in resolutions {
-            changed |= scope.push_res(name.clone(), *res);
+            changed |= scope.push_res(name.clone(), res.with_visibility(vis));
        }
        if !changed {
@@ -459,9 +489,13 @@ where
            .flat_map(|v| v.iter())
            .cloned()
            .collect::<Vec<_>>();
-        for (glob_importing_module, _glob_import) in glob_imports {
+        for (glob_importing_module, glob_import_vis) in glob_imports {
-            // We pass the glob import so that the tracked import in those modules is that glob import
+            // we know all resolutions have the same visibility (`vis`), so we
-            self.update_recursive(glob_importing_module, resolutions, depth + 1);
+            // just need to check that once
+            if !vis.is_visible_from_def_map(&self.def_map, glob_importing_module) {
+                continue;
+            }
+            self.update_recursive(glob_importing_module, resolutions, glob_import_vis, depth + 1);
        }
    }
@@ -633,9 +667,13 @@ where
        let is_macro_use = attrs.by_key("macro_use").exists();
        match module {
            // inline module, just recurse
-            raw::ModuleData::Definition { name, items, ast_id } => {
+            raw::ModuleData::Definition { name, visibility, items, ast_id } => {
-                let module_id =
+                let module_id = self.push_child_module(
-                    self.push_child_module(name.clone(), AstId::new(self.file_id, *ast_id), None);
+                    name.clone(),
+                    AstId::new(self.file_id, *ast_id),
+                    None,
+                    &visibility,
+                );
                ModCollector {
                    def_collector: &mut *self.def_collector,
@@ -650,7 +688,7 @@ where
                }
            }
            // out of line module, resolve, parse and recurse
-            raw::ModuleData::Declaration { name, ast_id } => {
+            raw::ModuleData::Declaration { name, visibility, ast_id } => {
                let ast_id = AstId::new(self.file_id, *ast_id);
                match self.mod_dir.resolve_declaration(
                    self.def_collector.db,
@@ -659,7 +697,12 @@ where
                    path_attr,
                ) {
                    Ok((file_id, mod_dir)) => {
-                        let module_id = self.push_child_module(name.clone(), ast_id, Some(file_id));
+                        let module_id = self.push_child_module(
+                            name.clone(),
+                            ast_id,
+                            Some(file_id),
+                            &visibility,
+                        );
                        let raw_items = self.def_collector.db.raw_items(file_id.into());
                        ModCollector {
                            def_collector: &mut *self.def_collector,
@@ -690,7 +733,13 @@ where
        name: Name,
        declaration: AstId<ast::Module>,
        definition: Option<FileId>,
+        visibility: &crate::visibility::RawVisibility,
    ) -> LocalModuleId {
+        let vis = self
+            .def_collector
+            .def_map
+            .resolve_visibility(self.def_collector.db, self.module_id, visibility)
+            .unwrap_or(Visibility::Public);
        let modules = &mut self.def_collector.def_map.modules;
        let res = modules.alloc(ModuleData::default());
        modules[res].parent = Some(self.module_id);
@@ -702,7 +751,7 @@ where
        let module = ModuleId { krate: self.def_collector.def_map.krate, local_id: res };
        let def: ModuleDefId = module.into();
        self.def_collector.def_map.modules[self.module_id].scope.define_def(def);
-        self.def_collector.update(self.module_id, &[(name, def.into())]);
+        self.def_collector.update(self.module_id, &[(name, PerNs::from_def(def, vis))], vis);
        res
    }
@@ -716,6 +765,7 @@ where
        let name = def.name.clone();
        let container = ContainerId::ModuleId(module);
+        let vis = &def.visibility;
        let def: ModuleDefId = match def.kind {
            raw::DefKind::Function(ast_id) => FunctionLoc {
                container: container.into(),
@@ -761,7 +811,12 @@ where
            .into(),
        };
        self.def_collector.def_map.modules[self.module_id].scope.define_def(def);
-        self.def_collector.update(self.module_id, &[(name, def.into())])
+        let vis = self
+            .def_collector
+            .def_map
+            .resolve_visibility(self.def_collector.db, self.module_id, vis)
+            .unwrap_or(Visibility::Public);
+        self.def_collector.update(self.module_id, &[(name, PerNs::from_def(def, vis))], vis)
    }
    fn collect_derives(&mut self, attrs: &Attrs, def: &raw::DefData) {
diff --git a/crates/ra_hir_def/src/nameres/path_resolution.rs b/crates/ra_hir_def/src/nameres/path_resolution.rs
index 695014c7b..fd6422d60 100644
--- a/crates/ra_hir_def/src/nameres/path_resolution.rs
+++ b/crates/ra_hir_def/src/nameres/path_resolution.rs
@@ -21,6 +21,7 @@ use crate::{
    nameres::{BuiltinShadowMode, CrateDefMap},
    path::{ModPath, PathKind},
    per_ns::PerNs,
+    visibility::{RawVisibility, Visibility},
    AdtId, CrateId, EnumVariantId, LocalModuleId, ModuleDefId, ModuleId,
 };
@@ -61,7 +62,35 @@ impl ResolvePathResult {
 impl CrateDefMap {
    pub(super) fn resolve_name_in_extern_prelude(&self, name: &Name) -> PerNs {
-        self.extern_prelude.get(name).map_or(PerNs::none(), |&it| PerNs::types(it))
+        self.extern_prelude
+            .get(name)
+            .map_or(PerNs::none(), |&it| PerNs::types(it, Visibility::Public))
+    }
+    pub(crate) fn resolve_visibility(
+        &self,
+        db: &impl DefDatabase,
+        original_module: LocalModuleId,
+        visibility: &RawVisibility,
+    ) -> Option<Visibility> {
+        match visibility {
+            RawVisibility::Module(path) => {
+                let (result, remaining) =
+                    self.resolve_path(db, original_module, &path, BuiltinShadowMode::Module);
+                if remaining.is_some() {
+                    return None;
+                }
+                let types = result.take_types()?;
+                match types {
+                    ModuleDefId::ModuleId(m) => Some(Visibility::Module(m)),
+                    _ => {
+                        // error: visibility needs to refer to module
+                        None
+                    }
+                }
+            }
+            RawVisibility::Public => Some(Visibility::Public),
+        }
    }
    // Returns Yes if we are sure that additions to `ItemMap` wouldn't change
@@ -88,17 +117,21 @@ impl CrateDefMap {
            PathKind::DollarCrate(krate) => {
                if krate == self.krate {
                    tested_by!(macro_dollar_crate_self);
-                    PerNs::types(ModuleId { krate: self.krate, local_id: self.root }.into())
+                    PerNs::types(
+                        ModuleId { krate: self.krate, local_id: self.root }.into(),
+                        Visibility::Public,
+                    )
                } else {
                    let def_map = db.crate_def_map(krate);
                    let module = ModuleId { krate, local_id: def_map.root };
                    tested_by!(macro_dollar_crate_other);
-                    PerNs::types(module.into())
+                    PerNs::types(module.into(), Visibility::Public)
                }
            }
-            PathKind::Crate => {
+            PathKind::Crate => PerNs::types(
-                PerNs::types(ModuleId { krate: self.krate, local_id: self.root }.into())
+                ModuleId { krate: self.krate, local_id: self.root }.into(),
-            }
+                Visibility::Public,
+            ),
            // plain import or absolute path in 2015: crate-relative with
            // fallback to extern prelude (with the simplification in
            // rust-lang/rust#57745)
@@ -126,7 +159,10 @@ impl CrateDefMap {
                let m = successors(Some(original_module), |m| self.modules[*m].parent)
                    .nth(lvl as usize);
                if let Some(local_id) = m {
-                    PerNs::types(ModuleId { krate: self.krate, local_id }.into())
+                    PerNs::types(
+                        ModuleId { krate: self.krate, local_id }.into(),
+                        Visibility::Public,
+                    )
                } else {
                    log::debug!("super path in root module");
                    return ResolvePathResult::empty(ReachedFixedPoint::Yes);
@@ -140,7 +176,7 @@ impl CrateDefMap {
                };
                if let Some(def) = self.extern_prelude.get(&segment) {
                    log::debug!("absolute path {:?} resolved to crate {:?}", path, def);
-                    PerNs::types(*def)
+                    PerNs::types(*def, Visibility::Public)
                } else {
                    return ResolvePathResult::empty(ReachedFixedPoint::No); // extern crate declarations can add to the extern prelude
                }
@@ -148,7 +184,7 @@ impl CrateDefMap {
        };
        for (i, segment) in segments {
-            let curr = match curr_per_ns.take_types() {
+            let (curr, vis) = match curr_per_ns.take_types_vis() {
                Some(r) => r,
                None => {
                    // we still have path segments left, but the path so far
@@ -189,11 +225,11 @@ impl CrateDefMap {
                    match enum_data.variant(&segment) {
                        Some(local_id) => {
                            let variant = EnumVariantId { parent: e, local_id };
-                            PerNs::both(variant.into(), variant.into())
+                            PerNs::both(variant.into(), variant.into(), Visibility::Public)
                        }
                        None => {
                            return ResolvePathResult::with(
-                                PerNs::types(e.into()),
+                                PerNs::types(e.into(), vis),
                                ReachedFixedPoint::Yes,
                                Some(i),
                                Some(self.krate),
@@ -211,7 +247,7 @@ impl CrateDefMap {
                    );
                    return ResolvePathResult::with(
-                        PerNs::types(s),
+                        PerNs::types(s, vis),
                        ReachedFixedPoint::Yes,
                        Some(i),
                        Some(self.krate),
@@ -235,11 +271,15 @@ impl CrateDefMap {
        //  - current module / scope
        //  - extern prelude
        //  - std prelude
-        let from_legacy_macro =
+        let from_legacy_macro = self[module]
-            self[module].scope.get_legacy_macro(name).map_or_else(PerNs::none, PerNs::macros);
+            .scope
+            .get_legacy_macro(name)
+            .map_or_else(PerNs::none, |m| PerNs::macros(m, Visibility::Public));
        let from_scope = self[module].scope.get(name, shadow);
-        let from_extern_prelude =
+        let from_extern_prelude = self
-            self.extern_prelude.get(name).map_or(PerNs::none(), |&it| PerNs::types(it));
+            .extern_prelude
+            .get(name)
+            .map_or(PerNs::none(), |&it| PerNs::types(it, Visibility::Public));
        let from_prelude = self.resolve_in_prelude(db, name, shadow);
        from_legacy_macro.or(from_scope).or(from_extern_prelude).or(from_prelude)
diff --git a/crates/ra_hir_def/src/nameres/raw.rs b/crates/ra_hir_def/src/nameres/raw.rs
index 73dc08745..fac1169ef 100644
--- a/crates/ra_hir_def/src/nameres/raw.rs
+++ b/crates/ra_hir_def/src/nameres/raw.rs
@@ -16,12 +16,15 @@ use hir_expand::{
 use ra_arena::{impl_arena_id, Arena, RawId};
 use ra_prof::profile;
 use ra_syntax::{
-    ast::{self, AttrsOwner, NameOwner},
+    ast::{self, AttrsOwner, NameOwner, VisibilityOwner},
    AstNode,
 };
 use test_utils::tested_by;
-use crate::{attr::Attrs, db::DefDatabase, path::ModPath, FileAstId, HirFileId, InFile};
+use crate::{
+    attr::Attrs, db::DefDatabase, path::ModPath, visibility::RawVisibility, FileAstId, HirFileId,
+    InFile,
+};
 /// `RawItems` is a set of top-level items in a file (except for impls).
 ///
@@ -122,8 +125,17 @@ impl_arena_id!(Module);
 #[derive(Debug, PartialEq, Eq)]
 pub(super) enum ModuleData {
-    Declaration { name: Name, ast_id: FileAstId<ast::Module> },
+    Declaration {
-    Definition { name: Name, ast_id: FileAstId<ast::Module>, items: Vec<RawItem> },
+        name: Name,
+        visibility: RawVisibility,
+        ast_id: FileAstId<ast::Module>,
+    },
+    Definition {
+        name: Name,
+        visibility: RawVisibility,
+        ast_id: FileAstId<ast::Module>,
+        items: Vec<RawItem>,
+    },
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -138,6 +150,7 @@ pub struct ImportData {
    pub(super) is_prelude: bool,
    pub(super) is_extern_crate: bool,
    pub(super) is_macro_use: bool,
+    pub(super) visibility: RawVisibility,
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -148,6 +161,7 @@ impl_arena_id!(Def);
 pub(super) struct DefData {
    pub(super) name: Name,
    pub(super) kind: DefKind,
+    pub(super) visibility: RawVisibility,
 }
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
@@ -218,6 +232,7 @@ impl RawItemsCollector {
    fn add_item(&mut self, current_module: Option<Module>, item: ast::ModuleItem) {
        let attrs = self.parse_attrs(&item);
+        let visibility = RawVisibility::from_ast_with_hygiene(item.visibility(), &self.hygiene);
        let (kind, name) = match item {
            ast::ModuleItem::Module(module) => {
                self.add_module(current_module, module);
@@ -266,7 +281,7 @@ impl RawItemsCollector {
        };
        if let Some(name) = name {
            let name = name.as_name();
-            let def = self.raw_items.defs.alloc(DefData { name, kind });
+            let def = self.raw_items.defs.alloc(DefData { name, kind, visibility });
            self.push_item(current_module, attrs, RawItemKind::Def(def));
        }
    }
@@ -277,10 +292,12 @@ impl RawItemsCollector {
            None => return,
        };
        let attrs = self.parse_attrs(&module);
+        let visibility = RawVisibility::from_ast_with_hygiene(module.visibility(), &self.hygiene);
        let ast_id = self.source_ast_id_map.ast_id(&module);
        if module.has_semi() {
-            let item = self.raw_items.modules.alloc(ModuleData::Declaration { name, ast_id });
+            let item =
+                self.raw_items.modules.alloc(ModuleData::Declaration { name, visibility, ast_id });
            self.push_item(current_module, attrs, RawItemKind::Module(item));
            return;
        }
@@ -288,6 +305,7 @@ impl RawItemsCollector {
        if let Some(item_list) = module.item_list() {
            let item = self.raw_items.modules.alloc(ModuleData::Definition {
                name,
+                visibility,
                ast_id,
                items: Vec::new(),
            });
@@ -302,6 +320,7 @@ impl RawItemsCollector {
        // FIXME: cfg_attr
        let is_prelude = use_item.has_atom_attr("prelude_import");
        let attrs = self.parse_attrs(&use_item);
+        let visibility = RawVisibility::from_ast_with_hygiene(use_item.visibility(), &self.hygiene);
        let mut buf = Vec::new();
        ModPath::expand_use_item(
@@ -315,6 +334,7 @@ impl RawItemsCollector {
                    is_prelude,
                    is_extern_crate: false,
                    is_macro_use: false,
+                    visibility: visibility.clone(),
                };
                buf.push(import_data);
            },
@@ -331,6 +351,8 @@ impl RawItemsCollector {
    ) {
        if let Some(name_ref) = extern_crate.name_ref() {
            let path = ModPath::from_name_ref(&name_ref);
+            let visibility =
+                RawVisibility::from_ast_with_hygiene(extern_crate.visibility(), &self.hygiene);
            let alias = extern_crate.alias().and_then(|a| a.name()).map(|it| it.as_name());
            let attrs = self.parse_attrs(&extern_crate);
            // FIXME: cfg_attr
@@ -342,6 +364,7 @@ impl RawItemsCollector {
                is_prelude: false,
                is_extern_crate: true,
                is_macro_use,
+                visibility,
            };
            self.push_import(current_module, attrs, import_data);
        }
diff --git a/crates/ra_hir_def/src/nameres/tests.rs b/crates/ra_hir_def/src/nameres/tests.rs
index ff474b53b..78bcdc850 100644
--- a/crates/ra_hir_def/src/nameres/tests.rs
+++ b/crates/ra_hir_def/src/nameres/tests.rs
@@ -12,8 +12,8 @@ use test_utils::covers;
 use crate::{db::DefDatabase, nameres::*, test_db::TestDB, LocalModuleId};
-fn def_map(fixtute: &str) -> String {
+fn def_map(fixture: &str) -> String {
-    let dm = compute_crate_def_map(fixtute);
+    let dm = compute_crate_def_map(fixture);
    render_crate_def_map(&dm)
 }
@@ -32,7 +32,7 @@ fn render_crate_def_map(map: &CrateDefMap) -> String {
        *buf += path;
        *buf += "\n";
-        let mut entries = map.modules[module].scope.collect_resolutions();
+        let mut entries: Vec<_> = map.modules[module].scope.resolutions().collect();
        entries.sort_by_key(|(name, _)| name.clone());
        for (name, def) in entries {
diff --git a/crates/ra_hir_def/src/nameres/tests/globs.rs b/crates/ra_hir_def/src/nameres/tests/globs.rs
index 5e24cb94d..71fa0abe8 100644
--- a/crates/ra_hir_def/src/nameres/tests/globs.rs
+++ b/crates/ra_hir_def/src/nameres/tests/globs.rs
@@ -74,6 +74,83 @@ fn glob_2() {
 }
 #[test]
+fn glob_privacy_1() {
+    let map = def_map(
+        "
+        //- /lib.rs
+        mod foo;
+        use foo::*;
+        //- /foo/mod.rs
+        pub mod bar;
+        pub use self::bar::*;
+        struct PrivateStructFoo;
+        //- /foo/bar.rs
+        pub struct Baz;
+        struct PrivateStructBar;
+        pub use super::*;
+        ",
+    );
+    assert_snapshot!(map, @r###"
+    crate
+    Baz: t v
+    bar: t
+    foo: t
+    
+    crate::foo
+    Baz: t v
+    PrivateStructFoo: t v
+    bar: t
+    
+    crate::foo::bar
+    Baz: t v
+    PrivateStructBar: t v
+    PrivateStructFoo: t v
+    bar: t
+    "###
+    );
+}
+#[test]
+fn glob_privacy_2() {
+    let map = def_map(
+        "
+        //- /lib.rs
+        mod foo;
+        use foo::*;
+        use foo::bar::*;
+        //- /foo/mod.rs
+        mod bar;
+        fn Foo() {};
+        pub struct Foo {};
+        //- /foo/bar.rs
+        pub(super) struct PrivateBaz;
+        struct PrivateBar;
+        pub(crate) struct PubCrateStruct;
+        ",
+    );
+    assert_snapshot!(map, @r###"
+    crate
+    Foo: t
+    PubCrateStruct: t v
+    foo: t
+    
+    crate::foo
+    Foo: t v
+    bar: t
+    
+    crate::foo::bar
+    PrivateBar: t v
+    PrivateBaz: t v
+    PubCrateStruct: t v
+    "###
+    );
+}
+#[test]
 fn glob_across_crates() {
    covers!(glob_across_crates);
    let map = def_map(
@@ -93,6 +170,26 @@ fn glob_across_crates() {
 }
 #[test]
+fn glob_privacy_across_crates() {
+    covers!(glob_across_crates);
+    let map = def_map(
+        "
+        //- /main.rs crate:main deps:test_crate
+        use test_crate::*;
+        //- /lib.rs crate:test_crate
+        pub struct Baz;
+        struct Foo;
+        ",
+    );
+    assert_snapshot!(map, @r###"
+   ⋮crate
+   ⋮Baz: t v
+    "###
+    );
+}
+#[test]
 fn glob_enum() {
    covers!(glob_enum);
    let map = def_map(
diff --git a/crates/ra_hir_def/src/nameres/tests/incremental.rs b/crates/ra_hir_def/src/nameres/tests/incremental.rs
index ef2e9435c..faeb7aa4d 100644
--- a/crates/ra_hir_def/src/nameres/tests/incremental.rs
+++ b/crates/ra_hir_def/src/nameres/tests/incremental.rs
@@ -116,7 +116,7 @@ fn typing_inside_a_macro_should_not_invalidate_def_map() {
        let events = db.log_executed(|| {
            let crate_def_map = db.crate_def_map(krate);
            let (_, module_data) = crate_def_map.modules.iter().last().unwrap();
-            assert_eq!(module_data.scope.collect_resolutions().len(), 1);
+            assert_eq!(module_data.scope.resolutions().collect::<Vec<_>>().len(), 1);
        });
        assert!(format!("{:?}", events).contains("crate_def_map"), "{:#?}", events)
    }
@@ -126,7 +126,7 @@ fn typing_inside_a_macro_should_not_invalidate_def_map() {
        let events = db.log_executed(|| {
            let crate_def_map = db.crate_def_map(krate);
            let (_, module_data) = crate_def_map.modules.iter().last().unwrap();
-            assert_eq!(module_data.scope.collect_resolutions().len(), 1);
+            assert_eq!(module_data.scope.resolutions().collect::<Vec<_>>().len(), 1);
        });
        assert!(!format!("{:?}", events).contains("crate_def_map"), "{:#?}", events)
    }
diff --git a/crates/ra_hir_def/src/path.rs b/crates/ra_hir_def/src/path.rs
index 107d2d799..82cfa67a9 100644
--- a/crates/ra_hir_def/src/path.rs
+++ b/crates/ra_hir_def/src/path.rs
@@ -260,12 +260,8 @@ macro_rules! __known_path {
    (std::ops::RangeTo) => {};
    (std::ops::RangeToInclusive) => {};
    (std::ops::RangeInclusive) => {};
-    (std::boxed::Box) => {};
    (std::future::Future) => {};
    (std::ops::Try) => {};
-    (std::ops::Neg) => {};
-    (std::ops::Not) => {};
-    (std::ops::Index) => {};
    ($path:path) => {
        compile_error!("Please register your known path in the path module")
    };
diff --git a/crates/ra_hir_def/src/per_ns.rs b/crates/ra_hir_def/src/per_ns.rs
index 3a5105028..6e435c8c1 100644
--- a/crates/ra_hir_def/src/per_ns.rs
+++ b/crates/ra_hir_def/src/per_ns.rs
@@ -5,13 +5,13 @@
 use hir_expand::MacroDefId;
-use crate::ModuleDefId;
+use crate::{visibility::Visibility, ModuleDefId};
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub struct PerNs {
-    pub types: Option<ModuleDefId>,
+    pub types: Option<(ModuleDefId, Visibility)>,
-    pub values: Option<ModuleDefId>,
+    pub values: Option<(ModuleDefId, Visibility)>,
-    pub macros: Option<MacroDefId>,
+    pub macros: Option<(MacroDefId, Visibility)>,
 }
 impl Default for PerNs {
@@ -25,20 +25,20 @@ impl PerNs {
        PerNs { types: None, values: None, macros: None }
    }
-    pub fn values(t: ModuleDefId) -> PerNs {
+    pub fn values(t: ModuleDefId, v: Visibility) -> PerNs {
-        PerNs { types: None, values: Some(t), macros: None }
+        PerNs { types: None, values: Some((t, v)), macros: None }
    }
-    pub fn types(t: ModuleDefId) -> PerNs {
+    pub fn types(t: ModuleDefId, v: Visibility) -> PerNs {
-        PerNs { types: Some(t), values: None, macros: None }
+        PerNs { types: Some((t, v)), values: None, macros: None }
    }
-    pub fn both(types: ModuleDefId, values: ModuleDefId) -> PerNs {
+    pub fn both(types: ModuleDefId, values: ModuleDefId, v: Visibility) -> PerNs {
-        PerNs { types: Some(types), values: Some(values), macros: None }
+        PerNs { types: Some((types, v)), values: Some((values, v)), macros: None }
    }
-    pub fn macros(macro_: MacroDefId) -> PerNs {
+    pub fn macros(macro_: MacroDefId, v: Visibility) -> PerNs {
-        PerNs { types: None, values: None, macros: Some(macro_) }
+        PerNs { types: None, values: None, macros: Some((macro_, v)) }
    }
    pub fn is_none(&self) -> bool {
@@ -46,15 +46,35 @@ impl PerNs {
    }
    pub fn take_types(self) -> Option<ModuleDefId> {
+        self.types.map(|it| it.0)
+    }
+    pub fn take_types_vis(self) -> Option<(ModuleDefId, Visibility)> {
        self.types
    }
    pub fn take_values(self) -> Option<ModuleDefId> {
-        self.values
+        self.values.map(|it| it.0)
    }
    pub fn take_macros(self) -> Option<MacroDefId> {
-        self.macros
+        self.macros.map(|it| it.0)
+    }
+    pub fn filter_visibility(self, mut f: impl FnMut(Visibility) -> bool) -> PerNs {
+        PerNs {
+            types: self.types.filter(|(_, v)| f(*v)),
+            values: self.values.filter(|(_, v)| f(*v)),
+            macros: self.macros.filter(|(_, v)| f(*v)),
+        }
+    }
+    pub fn with_visibility(self, vis: Visibility) -> PerNs {
+        PerNs {
+            types: self.types.map(|(it, _)| (it, vis)),
+            values: self.values.map(|(it, _)| (it, vis)),
+            macros: self.macros.map(|(it, _)| (it, vis)),
+        }
    }
    pub fn or(self, other: PerNs) -> PerNs {
diff --git a/crates/ra_hir_def/src/resolver.rs b/crates/ra_hir_def/src/resolver.rs
index cf3c33d78..5d16dd087 100644
--- a/crates/ra_hir_def/src/resolver.rs
+++ b/crates/ra_hir_def/src/resolver.rs
@@ -19,6 +19,7 @@ use crate::{
    nameres::CrateDefMap,
    path::{ModPath, PathKind},
    per_ns::PerNs,
+    visibility::{RawVisibility, Visibility},
    AdtId, AssocContainerId, ConstId, ContainerId, DefWithBodyId, EnumId, EnumVariantId,
    FunctionId, GenericDefId, HasModule, ImplId, LocalModuleId, Lookup, ModuleDefId, ModuleId,
    StaticId, StructId, TraitId, TypeAliasId, TypeParamId, VariantId,
@@ -231,6 +232,23 @@ impl Resolver {
        Some(res)
    }
+    pub fn resolve_visibility(
+        &self,
+        db: &impl DefDatabase,
+        visibility: &RawVisibility,
+    ) -> Option<Visibility> {
+        match visibility {
+            RawVisibility::Module(_) => {
+                let (item_map, module) = match self.module() {
+                    Some(it) => it,
+                    None => return None,
+                };
+                item_map.resolve_visibility(db, module, visibility)
+            }
+            RawVisibility::Public => Some(Visibility::Public),
+        }
+    }
    pub fn resolve_path_in_value_ns(
        &self,
        db: &impl DefDatabase,
@@ -448,10 +466,10 @@ impl Scope {
                    f(name.clone(), ScopeDef::PerNs(def));
                });
                m.crate_def_map[m.module_id].scope.legacy_macros().for_each(|(name, macro_)| {
-                    f(name.clone(), ScopeDef::PerNs(PerNs::macros(macro_)));
+                    f(name.clone(), ScopeDef::PerNs(PerNs::macros(macro_, Visibility::Public)));
                });
                m.crate_def_map.extern_prelude.iter().for_each(|(name, &def)| {
-                    f(name.clone(), ScopeDef::PerNs(PerNs::types(def.into())));
+                    f(name.clone(), ScopeDef::PerNs(PerNs::types(def.into(), Visibility::Public)));
                });
                if let Some(prelude) = m.crate_def_map.prelude {
                    let prelude_def_map = db.crate_def_map(prelude.krate);
@@ -626,7 +644,7 @@ impl HasResolver for ContainerId {
    fn resolver(self, db: &impl DefDatabase) -> Resolver {
        match self {
            ContainerId::ModuleId(it) => it.resolver(db),
-            ContainerId::DefWithBodyId(it) => it.resolver(db),
+            ContainerId::DefWithBodyId(it) => it.module(db).resolver(db),
        }
    }
 }
diff --git a/crates/ra_hir_def/src/visibility.rs b/crates/ra_hir_def/src/visibility.rs
new file mode 100644
index 000000000..d8296da4b
--- /dev/null
+++ b/crates/ra_hir_def/src/visibility.rs
@@ -0,0 +1,120 @@
+//! Defines hir-level representation of visibility (e.g. `pub` and `pub(crate)`).
+use hir_expand::{hygiene::Hygiene, InFile};
+use ra_syntax::ast;
+use crate::{
+    db::DefDatabase,
+    path::{ModPath, PathKind},
+    ModuleId,
+};
+/// Visibility of an item, not yet resolved.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum RawVisibility {
+    /// `pub(in module)`, `pub(crate)` or `pub(super)`. Also private, which is
+    /// equivalent to `pub(self)`.
+    Module(ModPath),
+    /// `pub`.
+    Public,
+}
+impl RawVisibility {
+    const fn private() -> RawVisibility {
+        let path = ModPath { kind: PathKind::Super(0), segments: Vec::new() };
+        RawVisibility::Module(path)
+    }
+    pub(crate) fn from_ast(
+        db: &impl DefDatabase,
+        node: InFile<Option<ast::Visibility>>,
+    ) -> RawVisibility {
+        Self::from_ast_with_hygiene(node.value, &Hygiene::new(db, node.file_id))
+    }
+    pub(crate) fn from_ast_with_hygiene(
+        node: Option<ast::Visibility>,
+        hygiene: &Hygiene,
+    ) -> RawVisibility {
+        let node = match node {
+            None => return RawVisibility::private(),
+            Some(node) => node,
+        };
+        match node.kind() {
+            ast::VisibilityKind::In(path) => {
+                let path = ModPath::from_src(path, hygiene);
+                let path = match path {
+                    None => return RawVisibility::private(),
+                    Some(path) => path,
+                };
+                RawVisibility::Module(path)
+            }
+            ast::VisibilityKind::PubCrate => {
+                let path = ModPath { kind: PathKind::Crate, segments: Vec::new() };
+                RawVisibility::Module(path)
+            }
+            ast::VisibilityKind::PubSuper => {
+                let path = ModPath { kind: PathKind::Super(1), segments: Vec::new() };
+                RawVisibility::Module(path)
+            }
+            ast::VisibilityKind::Pub => RawVisibility::Public,
+        }
+    }
+    pub fn resolve(
+        &self,
+        db: &impl DefDatabase,
+        resolver: &crate::resolver::Resolver,
+    ) -> Visibility {
+        // we fall back to public visibility (i.e. fail open) if the path can't be resolved
+        resolver.resolve_visibility(db, self).unwrap_or(Visibility::Public)
+    }
+}
+/// Visibility of an item, with the path resolved.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum Visibility {
+    /// Visibility is restricted to a certain module.
+    Module(ModuleId),
+    /// Visibility is unrestricted.
+    Public,
+}
+impl Visibility {
+    pub fn is_visible_from(self, db: &impl DefDatabase, from_module: ModuleId) -> bool {
+        let to_module = match self {
+            Visibility::Module(m) => m,
+            Visibility::Public => return true,
+        };
+        // if they're not in the same crate, it can't be visible
+        if from_module.krate != to_module.krate {
+            return false;
+        }
+        let def_map = db.crate_def_map(from_module.krate);
+        self.is_visible_from_def_map(&def_map, from_module.local_id)
+    }
+    pub(crate) fn is_visible_from_other_crate(self) -> bool {
+        match self {
+            Visibility::Module(_) => false,
+            Visibility::Public => true,
+        }
+    }
+    pub(crate) fn is_visible_from_def_map(
+        self,
+        def_map: &crate::nameres::CrateDefMap,
+        from_module: crate::LocalModuleId,
+    ) -> bool {
+        let to_module = match self {
+            Visibility::Module(m) => m,
+            Visibility::Public => return true,
+        };
+        // from_module needs to be a descendant of to_module
+        let mut ancestors = std::iter::successors(Some(from_module), |m| {
+            let parent_id = def_map[*m].parent?;
+            Some(parent_id)
+        });
+        ancestors.any(|m| m == to_module.local_id)
+    }
+}
diff --git a/crates/ra_hir_ty/src/infer.rs b/crates/ra_hir_ty/src/infer.rs
index 32c0d07a5..37e69599d 100644
--- a/crates/ra_hir_ty/src/infer.rs
+++ b/crates/ra_hir_ty/src/infer.rs
@@ -24,6 +24,7 @@ use hir_def::{
    body::Body,
    data::{ConstData, FunctionData},
    expr::{BindingAnnotation, ExprId, PatId},
+    lang_item::LangItemTarget,
    path::{path, Path},
    resolver::{HasResolver, Resolver, TypeNs},
    type_ref::{Mutability, TypeRef},
@@ -32,6 +33,7 @@ use hir_def::{
 use hir_expand::{diagnostics::DiagnosticSink, name::name};
 use ra_arena::map::ArenaMap;
 use ra_prof::profile;
+use ra_syntax::SmolStr;
 use test_utils::tested_by;
 use super::{
@@ -482,6 +484,12 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        self.infer_expr_coerce(self.body.body_expr, &Expectation::has_type(self.return_ty.clone()));
    }
+    fn resolve_lang_item(&self, name: &str) -> Option<LangItemTarget> {
+        let krate = self.resolver.krate()?;
+        let name = SmolStr::new_inline_from_ascii(name.len(), name.as_bytes());
+        self.db.lang_item(krate, name)
+    }
    fn resolve_into_iter_item(&self) -> Option<TypeAliasId> {
        let path = path![std::iter::IntoIterator];
        let trait_ = self.resolver.resolve_known_trait(self.db, &path)?;
@@ -495,26 +503,22 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
    }
    fn resolve_ops_neg_output(&self) -> Option<TypeAliasId> {
-        let path = path![std::ops::Neg];
+        let trait_ = self.resolve_lang_item("neg")?.as_trait()?;
-        let trait_ = self.resolver.resolve_known_trait(self.db, &path)?;
        self.db.trait_data(trait_).associated_type_by_name(&name![Output])
    }
    fn resolve_ops_not_output(&self) -> Option<TypeAliasId> {
-        let path = path![std::ops::Not];
+        let trait_ = self.resolve_lang_item("not")?.as_trait()?;
-        let trait_ = self.resolver.resolve_known_trait(self.db, &path)?;
        self.db.trait_data(trait_).associated_type_by_name(&name![Output])
    }
    fn resolve_future_future_output(&self) -> Option<TypeAliasId> {
-        let path = path![std::future::Future];
+        let trait_ = self.resolve_lang_item("future_trait")?.as_trait()?;
-        let trait_ = self.resolver.resolve_known_trait(self.db, &path)?;
        self.db.trait_data(trait_).associated_type_by_name(&name![Output])
    }
    fn resolve_boxed_box(&self) -> Option<AdtId> {
-        let path = path![std::boxed::Box];
+        let struct_ = self.resolve_lang_item("owned_box")?.as_struct()?;
-        let struct_ = self.resolver.resolve_known_struct(self.db, &path)?;
        Some(struct_.into())
    }
@@ -555,8 +559,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
    }
    fn resolve_ops_index_output(&self) -> Option<TypeAliasId> {
-        let path = path![std::ops::Index];
+        let trait_ = self.resolve_lang_item("index")?.as_trait()?;
-        let trait_ = self.resolver.resolve_known_trait(self.db, &path)?;
        self.db.trait_data(trait_).associated_type_by_name(&name![Output])
    }
 }
diff --git a/crates/ra_hir_ty/src/tests.rs b/crates/ra_hir_ty/src/tests.rs
index d447b4571..d1f10e675 100644
--- a/crates/ra_hir_ty/src/tests.rs
+++ b/crates/ra_hir_ty/src/tests.rs
@@ -11,8 +11,8 @@ use std::fmt::Write;
 use std::sync::Arc;
 use hir_def::{
-    body::BodySourceMap, child_by_source::ChildBySource, db::DefDatabase, keys,
+    body::BodySourceMap, child_by_source::ChildBySource, db::DefDatabase, item_scope::ItemScope,
-    nameres::CrateDefMap, AssocItemId, DefWithBodyId, LocalModuleId, Lookup, ModuleDefId,
+    keys, nameres::CrateDefMap, AssocItemId, DefWithBodyId, LocalModuleId, Lookup, ModuleDefId,
 };
 use hir_expand::InFile;
 use insta::assert_snapshot;
@@ -163,35 +163,69 @@ fn visit_module(
    module_id: LocalModuleId,
    cb: &mut dyn FnMut(DefWithBodyId),
 ) {
-    for decl in crate_def_map[module_id].scope.declarations() {
+    visit_scope(db, crate_def_map, &crate_def_map[module_id].scope, cb);
-        match decl {
-            ModuleDefId::FunctionId(it) => cb(it.into()),
-            ModuleDefId::ConstId(it) => cb(it.into()),
-            ModuleDefId::StaticId(it) => cb(it.into()),
-            ModuleDefId::TraitId(it) => {
-                let trait_data = db.trait_data(it);
-                for &(_, item) in trait_data.items.iter() {
-                    match item {
-                        AssocItemId::FunctionId(it) => cb(it.into()),
-                        AssocItemId::ConstId(it) => cb(it.into()),
-                        AssocItemId::TypeAliasId(_) => (),
-                    }
-                }
-            }
-            ModuleDefId::ModuleId(it) => visit_module(db, crate_def_map, it.local_id, cb),
-            _ => (),
-        }
-    }
    for impl_id in crate_def_map[module_id].scope.impls() {
        let impl_data = db.impl_data(impl_id);
        for &item in impl_data.items.iter() {
            match item {
-                AssocItemId::FunctionId(it) => cb(it.into()),
+                AssocItemId::FunctionId(it) => {
-                AssocItemId::ConstId(it) => cb(it.into()),
+                    let def = it.into();
+                    cb(def);
+                    let body = db.body(def);
+                    visit_scope(db, crate_def_map, &body.item_scope, cb);
+                }
+                AssocItemId::ConstId(it) => {
+                    let def = it.into();
+                    cb(def);
+                    let body = db.body(def);
+                    visit_scope(db, crate_def_map, &body.item_scope, cb);
+                }
                AssocItemId::TypeAliasId(_) => (),
            }
        }
    }
+    fn visit_scope(
+        db: &TestDB,
+        crate_def_map: &CrateDefMap,
+        scope: &ItemScope,
+        cb: &mut dyn FnMut(DefWithBodyId),
+    ) {
+        for decl in scope.declarations() {
+            match decl {
+                ModuleDefId::FunctionId(it) => {
+                    let def = it.into();
+                    cb(def);
+                    let body = db.body(def);
+                    visit_scope(db, crate_def_map, &body.item_scope, cb);
+                }
+                ModuleDefId::ConstId(it) => {
+                    let def = it.into();
+                    cb(def);
+                    let body = db.body(def);
+                    visit_scope(db, crate_def_map, &body.item_scope, cb);
+                }
+                ModuleDefId::StaticId(it) => {
+                    let def = it.into();
+                    cb(def);
+                    let body = db.body(def);
+                    visit_scope(db, crate_def_map, &body.item_scope, cb);
+                }
+                ModuleDefId::TraitId(it) => {
+                    let trait_data = db.trait_data(it);
+                    for &(_, item) in trait_data.items.iter() {
+                        match item {
+                            AssocItemId::FunctionId(it) => cb(it.into()),
+                            AssocItemId::ConstId(it) => cb(it.into()),
+                            AssocItemId::TypeAliasId(_) => (),
+                        }
+                    }
+                }
+                ModuleDefId::ModuleId(it) => visit_module(db, crate_def_map, it.local_id, cb),
+                _ => (),
+            }
+        }
+    }
 }
 fn ellipsize(mut text: String, max_len: usize) -> String {
diff --git a/crates/ra_hir_ty/src/tests/regression.rs b/crates/ra_hir_ty/src/tests/regression.rs
index 09d684ac2..8b3aa8564 100644
--- a/crates/ra_hir_ty/src/tests/regression.rs
+++ b/crates/ra_hir_ty/src/tests/regression.rs
@@ -1,7 +1,8 @@
-use super::infer;
 use insta::assert_snapshot;
 use test_utils::covers;
+use super::infer;
 #[test]
 fn bug_484() {
    assert_snapshot!(
@@ -331,3 +332,36 @@ pub fn main_loop() {
    "###
    );
 }
+#[test]
+fn issue_2669() {
+    assert_snapshot!(
+        infer(
+            r#"trait A {}
+    trait Write {}
+    struct Response<T> {}
+    trait D {
+        fn foo();
+    }
+    impl<T:A> D for Response<T> {
+        fn foo() {
+            end();
+            fn end<W: Write>() {
+                let _x: T =  loop {};
+            }
+        }
+    }"#
+        ),
+        @r###"
+    [147; 262) '{     ...     }': ()
+    [161; 164) 'end': fn end<{unknown}>() -> ()
+    [161; 166) 'end()': ()
+    [199; 252) '{     ...     }': ()
+    [221; 223) '_x': !
+    [230; 237) 'loop {}': !
+    [235; 237) '{}': ()
+    "###
+    )
+}
diff --git a/crates/ra_hir_ty/src/tests/simple.rs b/crates/ra_hir_ty/src/tests/simple.rs
index 3e5e163e3..f7e042c12 100644
--- a/crates/ra_hir_ty/src/tests/simple.rs
+++ b/crates/ra_hir_ty/src/tests/simple.rs
@@ -20,6 +20,7 @@ fn test() {
 mod prelude {}
 mod boxed {
+    #[lang = "owned_box"]
    pub struct Box<T: ?Sized> {
        inner: *mut T,
    }
@@ -1518,6 +1519,7 @@ fn test() {
    [167; 179) 'GLOBAL_CONST': u32
    [189; 191) 'id': u32
    [194; 210) 'Foo::A..._CONST': u32
+    [126; 128) '99': u32
    "###
    );
 }
@@ -1549,6 +1551,8 @@ fn test() {
    [233; 246) 'GLOBAL_STATIC': u32
    [256; 257) 'w': u32
    [260; 277) 'GLOBAL...IC_MUT': u32
+    [118; 120) '99': u32
+    [161; 163) '99': u32
    "###
    );
 }
diff --git a/crates/ra_hir_ty/src/tests/traits.rs b/crates/ra_hir_ty/src/tests/traits.rs
index 0bc72644a..4b268510c 100644
--- a/crates/ra_hir_ty/src/tests/traits.rs
+++ b/crates/ra_hir_ty/src/tests/traits.rs
@@ -27,6 +27,7 @@ fn test() {
 //- /std.rs crate:std
 #[prelude_import] use future::*;
 mod future {
+    #[lang = "future_trait"]
    trait Future {
        type Output;
    }
@@ -56,6 +57,7 @@ fn test() {
 //- /std.rs crate:std
 #[prelude_import] use future::*;
 mod future {
+    #[lang = "future_trait"]
    trait Future {
        type Output;
    }
@@ -198,6 +200,7 @@ fn test() {
 #[prelude_import] use ops::*;
 mod ops {
+    #[lang = "neg"]
    pub trait Neg {
        type Output;
    }
@@ -230,6 +233,7 @@ fn test() {
 #[prelude_import] use ops::*;
 mod ops {
+    #[lang = "not"]
    pub trait Not {
        type Output;
    }
@@ -506,6 +510,7 @@ fn test() {
 #[prelude_import] use ops::*;
 mod ops {
+    #[lang = "index"]
    pub trait Index<Idx> {
        type Output;
    }
diff --git a/crates/ra_ide/src/completion/complete_dot.rs b/crates/ra_ide/src/completion/complete_dot.rs
index 294964887..210a685e4 100644
--- a/crates/ra_ide/src/completion/complete_dot.rs
+++ b/crates/ra_ide/src/completion/complete_dot.rs
@@ -1,6 +1,6 @@
 //! FIXME: write short doc here
-use hir::Type;
+use hir::{HasVisibility, Type};
 use crate::completion::completion_item::CompletionKind;
 use crate::{
@@ -38,9 +38,15 @@ pub(super) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
 fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: &Type) {
    for receiver in receiver.autoderef(ctx.db) {
        for (field, ty) in receiver.fields(ctx.db) {
+            if ctx.module.map_or(false, |m| !field.is_visible_from(ctx.db, m)) {
+                // Skip private field. FIXME: If the definition location of the
+                // field is editable, we should show the completion
+                continue;
+            }
            acc.add_field(ctx, field, &ty);
        }
        for (i, ty) in receiver.tuple_fields(ctx.db).into_iter().enumerate() {
+            // FIXME: Handle visibility
            acc.add_tuple_field(ctx, i, &ty);
        }
    }
@@ -187,6 +193,55 @@ mod tests {
    }
    #[test]
+    fn test_struct_field_visibility_private() {
+        assert_debug_snapshot!(
+            do_ref_completion(
+                r"
+            mod inner {
+                struct A {
+                    private_field: u32,
+                    pub pub_field: u32,
+                    pub(crate) crate_field: u32,
+                    pub(super) super_field: u32,
+                }
+            }
+            fn foo(a: inner::A) {
+               a.<|>
+            }
+            ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "crate_field",
+                source_range: [313; 313),
+                delete: [313; 313),
+                insert: "crate_field",
+                kind: Field,
+                detail: "u32",
+            },
+            CompletionItem {
+                label: "pub_field",
+                source_range: [313; 313),
+                delete: [313; 313),
+                insert: "pub_field",
+                kind: Field,
+                detail: "u32",
+            },
+            CompletionItem {
+                label: "super_field",
+                source_range: [313; 313),
+                delete: [313; 313),
+                insert: "super_field",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
    fn test_method_completion() {
        assert_debug_snapshot!(
        do_ref_completion(
diff --git a/crates/ra_ide/src/snapshots/highlighting.html b/crates/ra_ide/src/snapshots/highlighting.html
index a097cf8e8..1d130544f 100644
--- a/crates/ra_ide/src/snapshots/highlighting.html
+++ b/crates/ra_ide/src/snapshots/highlighting.html
@@ -38,12 +38,12 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="keyword">fn</span> <span class="function">main</span>() {
    <span class="macro">println</span><span class="macro">!</span>(<span class="string">"Hello, {}!"</span>, <span class="literal.numeric">92</span>);
-    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable.mut">vec</span> = <span class="text">Vec</span>::<span class="text">new</span>();
+    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable.mut">vec</span> = Vec::new();
    <span class="keyword.control">if</span> <span class="keyword">true</span> {
        <span class="keyword">let</span> <span class="variable">x</span> = <span class="literal.numeric">92</span>;
-        <span class="variable.mut">vec</span>.<span class="text">push</span>(<span class="type">Foo</span> { <span class="field">x</span>, <span class="field">y</span>: <span class="literal.numeric">1</span> });
+        <span class="variable.mut">vec</span>.push(<span class="type">Foo</span> { <span class="field">x</span>, <span class="field">y</span>: <span class="literal.numeric">1</span> });
    }
-    <span class="keyword.unsafe">unsafe</span> { <span class="variable.mut">vec</span>.<span class="text">set_len</span>(<span class="literal.numeric">0</span>); }
+    <span class="keyword.unsafe">unsafe</span> { <span class="variable.mut">vec</span>.set_len(<span class="literal.numeric">0</span>); }
    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable.mut">x</span> = <span class="literal.numeric">42</span>;
    <span class="keyword">let</span> <span class="variable.mut">y</span> = &<span class="keyword">mut</span> <span class="variable.mut">x</span>;
diff --git a/crates/ra_ide/src/snapshots/rainbow_highlighting.html b/crates/ra_ide/src/snapshots/rainbow_highlighting.html
index 110556c09..d90ee8540 100644
--- a/crates/ra_ide/src/snapshots/rainbow_highlighting.html
+++ b/crates/ra_ide/src/snapshots/rainbow_highlighting.html
@@ -25,11 +25,11 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 </style>
 <pre><code><span class="keyword">fn</span> <span class="function">main</span>() {
    <span class="keyword">let</span> <span class="variable" data-binding-hash="8723171760279909834" style="color: hsl(307,91%,75%);">hello</span> = <span class="string">"hello"</span>;
-    <span class="keyword">let</span> <span class="variable" data-binding-hash="14702933417323009544" style="color: hsl(108,90%,49%);">x</span> = <span class="variable" data-binding-hash="8723171760279909834" style="color: hsl(307,91%,75%);">hello</span>.<span class="text">to_string</span>();
+    <span class="keyword">let</span> <span class="variable" data-binding-hash="14702933417323009544" style="color: hsl(108,90%,49%);">x</span> = <span class="variable" data-binding-hash="8723171760279909834" style="color: hsl(307,91%,75%);">hello</span>.to_string();
-    <span class="keyword">let</span> <span class="variable" data-binding-hash="5443150872754369068" style="color: hsl(215,43%,43%);">y</span> = <span class="variable" data-binding-hash="8723171760279909834" style="color: hsl(307,91%,75%);">hello</span>.<span class="text">to_string</span>();
+    <span class="keyword">let</span> <span class="variable" data-binding-hash="5443150872754369068" style="color: hsl(215,43%,43%);">y</span> = <span class="variable" data-binding-hash="8723171760279909834" style="color: hsl(307,91%,75%);">hello</span>.to_string();
    <span class="keyword">let</span> <span class="variable" data-binding-hash="17358108296605513516" style="color: hsl(331,46%,60%);">x</span> = <span class="string">"other color please!"</span>;
-    <span class="keyword">let</span> <span class="variable" data-binding-hash="2073121142529774969" style="color: hsl(320,43%,74%);">y</span> = <span class="variable" data-binding-hash="17358108296605513516" style="color: hsl(331,46%,60%);">x</span>.<span class="text">to_string</span>();
+    <span class="keyword">let</span> <span class="variable" data-binding-hash="2073121142529774969" style="color: hsl(320,43%,74%);">y</span> = <span class="variable" data-binding-hash="17358108296605513516" style="color: hsl(331,46%,60%);">x</span>.to_string();
 }
 <span class="keyword">fn</span> <span class="function">bar</span>() {
diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs
index 0228ee7e9..56a36f587 100644
--- a/crates/ra_ide/src/syntax_highlighting.rs
+++ b/crates/ra_ide/src/syntax_highlighting.rs
@@ -20,13 +20,13 @@ pub mod tags {
    pub(crate) const FIELD: &str = "field";
    pub(crate) const FUNCTION: &str = "function";
    pub(crate) const MODULE: &str = "module";
-    pub(crate) const TYPE: &str = "type";
    pub(crate) const CONSTANT: &str = "constant";
    pub(crate) const MACRO: &str = "macro";
    pub(crate) const VARIABLE: &str = "variable";
    pub(crate) const VARIABLE_MUT: &str = "variable.mut";
-    pub(crate) const TEXT: &str = "text";
+    pub(crate) const TYPE: &str = "type";
    pub(crate) const TYPE_BUILTIN: &str = "type.builtin";
    pub(crate) const TYPE_SELF: &str = "type.self";
    pub(crate) const TYPE_PARAM: &str = "type.param";
@@ -35,13 +35,14 @@ pub mod tags {
    pub(crate) const LITERAL_BYTE: &str = "literal.byte";
    pub(crate) const LITERAL_NUMERIC: &str = "literal.numeric";
    pub(crate) const LITERAL_CHAR: &str = "literal.char";
    pub(crate) const LITERAL_COMMENT: &str = "comment";
    pub(crate) const LITERAL_STRING: &str = "string";
    pub(crate) const LITERAL_ATTRIBUTE: &str = "attribute";
+    pub(crate) const KEYWORD: &str = "keyword";
    pub(crate) const KEYWORD_UNSAFE: &str = "keyword.unsafe";
    pub(crate) const KEYWORD_CONTROL: &str = "keyword.control";
-    pub(crate) const KEYWORD: &str = "keyword";
 }
 #[derive(Debug)]
@@ -109,15 +110,21 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
                let name_ref = node.as_node().cloned().and_then(ast::NameRef::cast).unwrap();
                let name_kind =
                    classify_name_ref(db, InFile::new(file_id.into(), &name_ref)).map(|d| d.kind);
+                match name_kind {
+                    Some(name_kind) => {
+                        if let Local(local) = &name_kind {
+                            if let Some(name) = local.name(db) {
+                                let shadow_count =
+                                    bindings_shadow_count.entry(name.clone()).or_default();
+                                binding_hash =
+                                    Some(calc_binding_hash(file_id, &name, *shadow_count))
+                            }
+                        };
-                if let Some(Local(local)) = &name_kind {
+                        highlight_name(db, name_kind)
-                    if let Some(name) = local.name(db) {
-                        let shadow_count = bindings_shadow_count.entry(name.clone()).or_default();
-                        binding_hash = Some(calc_binding_hash(file_id, &name, *shadow_count))
                    }
-                };
+                    _ => continue,
+                }
-                name_kind.map_or(tags::TEXT, |it| highlight_name(db, it))
            }
            NAME => {
                let name = node.as_node().cloned().and_then(ast::Name::cast).unwrap();
diff --git a/crates/ra_lsp_server/Cargo.toml b/crates/ra_lsp_server/Cargo.toml
index 030e9033c..9b7dcb6e9 100644
--- a/crates/ra_lsp_server/Cargo.toml
+++ b/crates/ra_lsp_server/Cargo.toml
@@ -27,6 +27,7 @@ ra_project_model = { path = "../ra_project_model" }
 ra_prof = { path = "../ra_prof" }
 ra_vfs_glob = { path = "../ra_vfs_glob" }
 env_logger = { version = "0.7.1", default-features = false, features = ["humantime"] }
+ra_cargo_watch = { path = "../ra_cargo_watch" }
 [dev-dependencies]
 tempfile = "3"
diff --git a/crates/ra_lsp_server/src/caps.rs b/crates/ra_lsp_server/src/caps.rs
index ceb4c4259..0dee1f6fe 100644
--- a/crates/ra_lsp_server/src/caps.rs
+++ b/crates/ra_lsp_server/src/caps.rs
@@ -3,7 +3,7 @@
 use lsp_types::{
    CodeActionProviderCapability, CodeLensOptions, CompletionOptions,
    DocumentOnTypeFormattingOptions, FoldingRangeProviderCapability,
-    ImplementationProviderCapability, RenameOptions, RenameProviderCapability,
+    ImplementationProviderCapability, RenameOptions, RenameProviderCapability, SaveOptions,
    SelectionRangeProviderCapability, ServerCapabilities, SignatureHelpOptions,
    TextDocumentSyncCapability, TextDocumentSyncKind, TextDocumentSyncOptions,
    TypeDefinitionProviderCapability, WorkDoneProgressOptions,
@@ -16,7 +16,7 @@ pub fn server_capabilities() -> ServerCapabilities {
            change: Some(TextDocumentSyncKind::Full),
            will_save: None,
            will_save_wait_until: None,
-            save: None,
+            save: Some(SaveOptions::default()),
        })),
        hover_provider: Some(true),
        completion_provider: Some(CompletionOptions {
diff --git a/crates/ra_lsp_server/src/config.rs b/crates/ra_lsp_server/src/config.rs
index 67942aa41..2d7948d74 100644
--- a/crates/ra_lsp_server/src/config.rs
+++ b/crates/ra_lsp_server/src/config.rs
@@ -32,6 +32,11 @@ pub struct ServerConfig {
    pub max_inlay_hint_length: Option<usize>,
+    pub cargo_watch_enable: bool,
+    pub cargo_watch_args: Vec<String>,
+    pub cargo_watch_command: String,
+    pub cargo_watch_all_targets: bool,
    /// For internal usage to make integrated tests faster.
    #[serde(deserialize_with = "nullable_bool_true")]
    pub with_sysroot: bool,
@@ -51,6 +56,10 @@ impl Default for ServerConfig {
            use_client_watching: false,
            lru_capacity: None,
            max_inlay_hint_length: None,
+            cargo_watch_enable: true,
+            cargo_watch_args: Vec::new(),
+            cargo_watch_command: "check".to_string(),
+            cargo_watch_all_targets: true,
            with_sysroot: true,
            feature_flags: FxHashMap::default(),
            cargo_features: Default::default(),
diff --git a/crates/ra_lsp_server/src/main_loop.rs b/crates/ra_lsp_server/src/main_loop.rs
index dda318e43..4336583fe 100644
--- a/crates/ra_lsp_server/src/main_loop.rs
+++ b/crates/ra_lsp_server/src/main_loop.rs
@@ -10,6 +10,7 @@ use std::{error::Error, fmt, panic, path::PathBuf, sync::Arc, time::Instant};
 use crossbeam_channel::{select, unbounded, RecvError, Sender};
 use lsp_server::{Connection, ErrorCode, Message, Notification, Request, RequestId, Response};
 use lsp_types::{ClientCapabilities, NumberOrString};
+use ra_cargo_watch::{CheckOptions, CheckTask};
 use ra_ide::{Canceled, FeatureFlags, FileId, LibraryData, SourceRootId};
 use ra_prof::profile;
 use ra_vfs::{VfsTask, Watch};
@@ -126,6 +127,12 @@ pub fn main_loop(
                    .and_then(|it| it.line_folding_only)
                    .unwrap_or(false),
                max_inlay_hint_length: config.max_inlay_hint_length,
+                cargo_watch: CheckOptions {
+                    enable: config.cargo_watch_enable,
+                    args: config.cargo_watch_args,
+                    command: config.cargo_watch_command,
+                    all_targets: config.cargo_watch_all_targets,
+                },
            }
        };
@@ -176,7 +183,11 @@ pub fn main_loop(
                    Ok(task) => Event::Vfs(task),
                    Err(RecvError) => Err("vfs died")?,
                },
-                recv(libdata_receiver) -> data => Event::Lib(data.unwrap())
+                recv(libdata_receiver) -> data => Event::Lib(data.unwrap()),
+                recv(world_state.check_watcher.task_recv) -> task => match task {
+                    Ok(task) => Event::CheckWatcher(task),
+                    Err(RecvError) => Err("check watcher died")?,
+                }
            };
            if let Event::Msg(Message::Request(req)) = &event {
                if connection.handle_shutdown(&req)? {
@@ -222,6 +233,7 @@ enum Event {
    Task(Task),
    Vfs(VfsTask),
    Lib(LibraryData),
+    CheckWatcher(CheckTask),
 }
 impl fmt::Debug for Event {
@@ -259,6 +271,7 @@ impl fmt::Debug for Event {
            Event::Task(it) => fmt::Debug::fmt(it, f),
            Event::Vfs(it) => fmt::Debug::fmt(it, f),
            Event::Lib(it) => fmt::Debug::fmt(it, f),
+            Event::CheckWatcher(it) => fmt::Debug::fmt(it, f),
        }
    }
 }
@@ -318,6 +331,28 @@ fn loop_turn(
            world_state.maybe_collect_garbage();
            loop_state.in_flight_libraries -= 1;
        }
+        Event::CheckWatcher(task) => match task {
+            CheckTask::Update(uri) => {
+                // We manually send a diagnostic update when the watcher asks
+                // us to, to avoid the issue of having to change the file to
+                // receive updated diagnostics.
+                let path = uri.to_file_path().map_err(|()| format!("invalid uri: {}", uri))?;
+                if let Some(file_id) = world_state.vfs.read().path2file(&path) {
+                    let params =
+                        handlers::publish_diagnostics(&world_state.snapshot(), FileId(file_id.0))?;
+                    let not = notification_new::<req::PublishDiagnostics>(params);
+                    task_sender.send(Task::Notify(not)).unwrap();
+                }
+            }
+            CheckTask::Status(progress) => {
+                let params = req::ProgressParams {
+                    token: req::ProgressToken::String("rustAnalyzer/cargoWatcher".to_string()),
+                    value: req::ProgressParamsValue::WorkDone(progress),
+                };
+                let not = notification_new::<req::Progress>(params);
+                task_sender.send(Task::Notify(not)).unwrap();
+            }
+        },
        Event::Msg(msg) => match msg {
            Message::Request(req) => on_request(
                world_state,
@@ -517,6 +552,13 @@ fn on_notification(
        }
        Err(not) => not,
    };
+    let not = match notification_cast::<req::DidSaveTextDocument>(not) {
+        Ok(_params) => {
+            state.check_watcher.update();
+            return Ok(());
+        }
+        Err(not) => not,
+    };
    let not = match notification_cast::<req::DidCloseTextDocument>(not) {
        Ok(params) => {
            let uri = params.text_document.uri;
@@ -667,16 +709,11 @@ where
            Ok(lsp_error) => Response::new_err(id, lsp_error.code, lsp_error.message),
            Err(e) => {
                if is_canceled(&e) {
-                    // FIXME: When https://github.com/Microsoft/vscode-languageserver-node/issues/457
+                    Response::new_err(
-                    // gets fixed, we can return the proper response.
+                        id,
-                    // This works around the issue where "content modified" error would continuously
+                        ErrorCode::ContentModified as i32,
-                    // show an message pop-up in VsCode
+                        "content modified".to_string(),
-                    // Response::err(
+                    )
-                    //     id,
-                    //     ErrorCode::ContentModified as i32,
-                    //     "content modified".to_string(),
-                    // )
-                    Response::new_ok(id, ())
                } else {
                    Response::new_err(id, ErrorCode::InternalError as i32, e.to_string())
                }
diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/ra_lsp_server/src/main_loop/handlers.rs
index 39eb3df3e..331beab13 100644
--- a/crates/ra_lsp_server/src/main_loop/handlers.rs
+++ b/crates/ra_lsp_server/src/main_loop/handlers.rs
@@ -654,6 +654,29 @@ pub fn handle_code_action(
        res.push(action.into());
    }
+    for fix in world.check_watcher.read().fixes_for(&params.text_document.uri).into_iter().flatten()
+    {
+        let fix_range = fix.location.range.conv_with(&line_index);
+        if fix_range.intersection(&range).is_none() {
+            continue;
+        }
+        let edits = vec![TextEdit::new(fix.location.range, fix.replacement.clone())];
+        let mut edit_map = std::collections::HashMap::new();
+        edit_map.insert(fix.location.uri.clone(), edits);
+        let edit = WorkspaceEdit::new(edit_map);
+        let action = CodeAction {
+            title: fix.title.clone(),
+            kind: Some("quickfix".to_string()),
+            diagnostics: Some(fix.diagnostics.clone()),
+            edit: Some(edit),
+            command: None,
+            is_preferred: None,
+        };
+        res.push(action.into());
+    }
    for assist in assists {
        let title = assist.change.label.clone();
        let edit = assist.change.try_conv_with(&world)?;
@@ -820,7 +843,7 @@ pub fn publish_diagnostics(
    let _p = profile("publish_diagnostics");
    let uri = world.file_id_to_uri(file_id)?;
    let line_index = world.analysis().file_line_index(file_id)?;
-    let diagnostics = world
+    let mut diagnostics: Vec<Diagnostic> = world
        .analysis()
        .diagnostics(file_id)?
        .into_iter()
@@ -834,6 +857,9 @@ pub fn publish_diagnostics(
            tags: None,
        })
        .collect();
+    if let Some(check_diags) = world.check_watcher.read().diagnostics_for(&uri) {
+        diagnostics.extend(check_diags.iter().cloned());
+    }
    Ok(req::PublishDiagnosticsParams { uri, diagnostics, version: None })
 }
diff --git a/crates/ra_lsp_server/src/req.rs b/crates/ra_lsp_server/src/req.rs
index b34e6f9b8..40edaf677 100644
--- a/crates/ra_lsp_server/src/req.rs
+++ b/crates/ra_lsp_server/src/req.rs
@@ -9,10 +9,10 @@ pub use lsp_types::{
    CodeLensParams, CompletionParams, CompletionResponse, DidChangeConfigurationParams,
    DidChangeWatchedFilesParams, DidChangeWatchedFilesRegistrationOptions,
    DocumentOnTypeFormattingParams, DocumentSymbolParams, DocumentSymbolResponse,
-    FileSystemWatcher, Hover, InitializeResult, MessageType, PublishDiagnosticsParams,
+    FileSystemWatcher, Hover, InitializeResult, MessageType, ProgressParams, ProgressParamsValue,
-    ReferenceParams, Registration, RegistrationParams, SelectionRange, SelectionRangeParams,
+    ProgressToken, PublishDiagnosticsParams, ReferenceParams, Registration, RegistrationParams,
-    ShowMessageParams, SignatureHelp, TextDocumentEdit, TextDocumentPositionParams, TextEdit,
+    SelectionRange, SelectionRangeParams, ShowMessageParams, SignatureHelp, TextDocumentEdit,
-    WorkspaceEdit, WorkspaceSymbolParams,
+    TextDocumentPositionParams, TextEdit, WorkspaceEdit, WorkspaceSymbolParams,
 };
 pub enum AnalyzerStatus {}
diff --git a/crates/ra_lsp_server/src/world.rs b/crates/ra_lsp_server/src/world.rs
index 79431e7e6..121ddfd1f 100644
--- a/crates/ra_lsp_server/src/world.rs
+++ b/crates/ra_lsp_server/src/world.rs
@@ -12,6 +12,9 @@ use crossbeam_channel::{unbounded, Receiver};
 use lsp_server::ErrorCode;
 use lsp_types::Url;
 use parking_lot::RwLock;
+use ra_cargo_watch::{
+    url_from_path_with_drive_lowercasing, CheckOptions, CheckWatcher, CheckWatcherSharedState,
+};
 use ra_ide::{
    Analysis, AnalysisChange, AnalysisHost, CrateGraph, FeatureFlags, FileId, LibraryData,
    SourceRootId,
@@ -20,13 +23,11 @@ use ra_project_model::{get_rustc_cfg_options, ProjectWorkspace};
 use ra_vfs::{LineEndings, RootEntry, Vfs, VfsChange, VfsFile, VfsRoot, VfsTask, Watch};
 use ra_vfs_glob::{Glob, RustPackageFilterBuilder};
 use relative_path::RelativePathBuf;
-use std::path::{Component, Prefix};
 use crate::{
    main_loop::pending_requests::{CompletedRequest, LatestRequests},
    LspError, Result,
 };
-use std::str::FromStr;
 #[derive(Debug, Clone)]
 pub struct Options {
@@ -34,6 +35,7 @@ pub struct Options {
    pub supports_location_link: bool,
    pub line_folding_only: bool,
    pub max_inlay_hint_length: Option<usize>,
+    pub cargo_watch: CheckOptions,
 }
 /// `WorldState` is the primary mutable state of the language server
@@ -52,6 +54,7 @@ pub struct WorldState {
    pub vfs: Arc<RwLock<Vfs>>,
    pub task_receiver: Receiver<VfsTask>,
    pub latest_requests: Arc<RwLock<LatestRequests>>,
+    pub check_watcher: CheckWatcher,
 }
 /// An immutable snapshot of the world's state at a point in time.
@@ -61,6 +64,7 @@ pub struct WorldSnapshot {
    pub analysis: Analysis,
    pub vfs: Arc<RwLock<Vfs>>,
    pub latest_requests: Arc<RwLock<LatestRequests>>,
+    pub check_watcher: Arc<RwLock<CheckWatcherSharedState>>,
 }
 impl WorldState {
@@ -127,6 +131,10 @@ impl WorldState {
        }
        change.set_crate_graph(crate_graph);
+        // FIXME: Figure out the multi-workspace situation
+        let check_watcher =
+            CheckWatcher::new(&options.cargo_watch, folder_roots.first().cloned().unwrap());
        let mut analysis_host = AnalysisHost::new(lru_capacity, feature_flags);
        analysis_host.apply_change(change);
        WorldState {
@@ -138,6 +146,7 @@ impl WorldState {
            vfs: Arc::new(RwLock::new(vfs)),
            task_receiver,
            latest_requests: Default::default(),
+            check_watcher,
        }
    }
@@ -199,6 +208,7 @@ impl WorldState {
            analysis: self.analysis_host.analysis(),
            vfs: Arc::clone(&self.vfs),
            latest_requests: Arc::clone(&self.latest_requests),
+            check_watcher: self.check_watcher.shared.clone(),
        }
    }
@@ -284,61 +294,3 @@ impl WorldSnapshot {
        self.analysis.feature_flags()
    }
 }
-/// Returns a `Url` object from a given path, will lowercase drive letters if present.
-/// This will only happen when processing windows paths.
-///
-/// When processing non-windows path, this is essentially the same as `Url::from_file_path`.
-fn url_from_path_with_drive_lowercasing(path: impl AsRef<Path>) -> Result<Url> {
-    let component_has_windows_drive = path.as_ref().components().any(|comp| {
-        if let Component::Prefix(c) = comp {
-            match c.kind() {
-                Prefix::Disk(_) | Prefix::VerbatimDisk(_) => return true,
-                _ => return false,
-            }
-        }
-        false
-    });
-    // VSCode expects drive letters to be lowercased, where rust will uppercase the drive letters.
-    if component_has_windows_drive {
-        let url_original = Url::from_file_path(&path)
-            .map_err(|_| format!("can't convert path to url: {}", path.as_ref().display()))?;
-        let drive_partition: Vec<&str> = url_original.as_str().rsplitn(2, ':').collect();
-        // There is a drive partition, but we never found a colon.
-        // This should not happen, but in this case we just pass it through.
-        if drive_partition.len() == 1 {
-            return Ok(url_original);
-        }
-        let joined = drive_partition[1].to_ascii_lowercase() + ":" + drive_partition[0];
-        let url = Url::from_str(&joined).expect("This came from a valid `Url`");
-        Ok(url)
-    } else {
-        Ok(Url::from_file_path(&path)
-            .map_err(|_| format!("can't convert path to url: {}", path.as_ref().display()))?)
-    }
-}
-// `Url` is not able to parse windows paths on unix machines.
-#[cfg(target_os = "windows")]
-#[cfg(test)]
-mod path_conversion_windows_tests {
-    use super::url_from_path_with_drive_lowercasing;
-    #[test]
-    fn test_lowercase_drive_letter_with_drive() {
-        let url = url_from_path_with_drive_lowercasing("C:\\Test").unwrap();
-        assert_eq!(url.to_string(), "file:///c:/Test");
-    }
-    #[test]
-    fn test_drive_without_colon_passthrough() {
-        let url = url_from_path_with_drive_lowercasing(r#"\\localhost\C$\my_dir"#).unwrap();
-        assert_eq!(url.to_string(), "file://localhost/C$/my_dir");
-    }
-}
diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs
index 277532a8c..89cb9a9f3 100644
--- a/crates/ra_syntax/src/ast.rs
+++ b/crates/ra_syntax/src/ast.rs
@@ -17,7 +17,9 @@ use crate::{
 pub use self::{
    expr_extensions::{ArrayExprKind, BinOp, ElseBranch, LiteralKind, PrefixOp, RangeOp},
-    extensions::{FieldKind, PathSegmentKind, SelfParamKind, StructKind, TypeBoundKind},
+    extensions::{
+        FieldKind, PathSegmentKind, SelfParamKind, StructKind, TypeBoundKind, VisibilityKind,
+    },
    generated::*,
    tokens::*,
    traits::*,
diff --git a/crates/ra_syntax/src/ast/extensions.rs b/crates/ra_syntax/src/ast/extensions.rs
index baaef3023..d9666cdca 100644
--- a/crates/ra_syntax/src/ast/extensions.rs
+++ b/crates/ra_syntax/src/ast/extensions.rs
@@ -413,3 +413,32 @@ impl ast::TraitDef {
        self.syntax().children_with_tokens().any(|t| t.kind() == T![auto])
    }
 }
+pub enum VisibilityKind {
+    In(ast::Path),
+    PubCrate,
+    PubSuper,
+    Pub,
+}
+impl ast::Visibility {
+    pub fn kind(&self) -> VisibilityKind {
+        if let Some(path) = children(self).next() {
+            VisibilityKind::In(path)
+        } else if self.is_pub_crate() {
+            VisibilityKind::PubCrate
+        } else if self.is_pub_super() {
+            VisibilityKind::PubSuper
+        } else {
+            VisibilityKind::Pub
+        }
+    }
+    fn is_pub_crate(&self) -> bool {
+        self.syntax().children_with_tokens().any(|it| it.kind() == T![crate])
+    }
+    fn is_pub_super(&self) -> bool {
+        self.syntax().children_with_tokens().any(|it| it.kind() == T![super])
+    }
+}
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index 9f9d6e63c..e64c83d33 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -1064,6 +1064,7 @@ impl AstNode for ExternCrateItem {
    }
 }
 impl ast::AttrsOwner for ExternCrateItem {}
+impl ast::VisibilityOwner for ExternCrateItem {}
 impl ExternCrateItem {
    pub fn name_ref(&self) -> Option<NameRef> {
        AstChildren::new(&self.syntax).next()
@@ -2006,6 +2007,7 @@ impl AstNode for ModuleItem {
    }
 }
 impl ast::AttrsOwner for ModuleItem {}
+impl ast::VisibilityOwner for ModuleItem {}
 impl ModuleItem {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Name {
@@ -3893,6 +3895,7 @@ impl AstNode for UseItem {
    }
 }
 impl ast::AttrsOwner for UseItem {}
+impl ast::VisibilityOwner for UseItem {}
 impl UseItem {
    pub fn use_tree(&self) -> Option<UseTree> {
        AstChildren::new(&self.syntax).next()
diff --git a/crates/ra_syntax/src/grammar.ron b/crates/ra_syntax/src/grammar.ron
index 08aafb610..e43a724f0 100644
--- a/crates/ra_syntax/src/grammar.ron
+++ b/crates/ra_syntax/src/grammar.ron
@@ -412,7 +412,7 @@ Grammar(
        "ModuleItem": (
            enum: ["StructDef", "UnionDef", "EnumDef", "FnDef", "TraitDef", "TypeAliasDef", "ImplBlock",
                   "UseItem", "ExternCrateItem", "ConstDef", "StaticDef", "Module" ],
-            traits: ["AttrsOwner"],
+            traits: ["AttrsOwner", "VisibilityOwner"],
        ),
        "ImplItem": (
            enum: ["FnDef", "TypeAliasDef", "ConstDef"],
@@ -683,7 +683,7 @@ Grammar(
            ]
        ),
        "UseItem": (
-            traits: ["AttrsOwner"],
+            traits: ["AttrsOwner", "VisibilityOwner"],
            options: [ "UseTree" ],
        ),
        "UseTree": (
@@ -696,7 +696,7 @@ Grammar(
            collections: [("use_trees", "UseTree")]
        ),
        "ExternCrateItem": (
-            traits: ["AttrsOwner"],
+            traits: ["AttrsOwner", "VisibilityOwner"],
            options: ["NameRef", "Alias"],
        ),
        "ArgList": (