23 files changed, 756 insertions, 653 deletions

diff --git a/crates/assists/src/handlers/ignore_test.rs b/crates/assists/src/handlers/ignore_test.rs
new file mode 100644
index 000000000..d2339184f
--- /dev/null
+++ b/crates/assists/src/handlers/ignore_test.rs
@@ -0,0 +1,34 @@
+use syntax::{ast, AstNode};
+
+use crate::{utils::test_related_attribute, AssistContext, AssistId, AssistKind, Assists};
+
+// Assist: ignore_test
+//
+// Adds `#[ignore]` attribute to the test.
+//
+// ```
+// <|>#[test]
+// fn arithmetics {
+//     assert_eq!(2 + 2, 5);
+// }
+// ```
+// ->
+// ```
+// #[test]
+// #[ignore]
+// fn arithmetics {
+//     assert_eq!(2 + 2, 5);
+// }
+// ```
+pub(crate) fn ignore_test(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let attr: ast::Attr = ctx.find_node_at_offset()?;
+    let func = attr.syntax().parent().and_then(ast::Fn::cast)?;
+    let attr = test_related_attribute(&func)?;
+
+    acc.add(
+        AssistId("ignore_test", AssistKind::None),
+        "Ignore this test",
+        attr.syntax().text_range(),
+        |builder| builder.insert(attr.syntax().text_range().end(), &format!("\n#[ignore]")),
+    )
+}
diff --git a/crates/assists/src/handlers/unwrap_block.rs b/crates/assists/src/handlers/unwrap_block.rs
index 36ef871b9..676db7137 100644
--- a/crates/assists/src/handlers/unwrap_block.rs
+++ b/crates/assists/src/handlers/unwrap_block.rs
@@ -3,7 +3,7 @@ use syntax::{
         self,
         edit::{AstNodeEdit, IndentLevel},
     },
-    AstNode, TextRange, T,
+    AstNode, SyntaxKind, TextRange, T,
 };
 
 use crate::{utils::unwrap_trivial_block, AssistContext, AssistId, AssistKind, Assists};
@@ -31,11 +31,21 @@ pub(crate) fn unwrap_block(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
 
     let l_curly_token = ctx.find_token_syntax_at_offset(T!['{'])?;
     let mut block = ast::BlockExpr::cast(l_curly_token.parent())?;
+    let target = block.syntax().text_range();
     let mut parent = block.syntax().parent()?;
     if ast::MatchArm::can_cast(parent.kind()) {
         parent = parent.ancestors().find(|it| ast::MatchExpr::can_cast(it.kind()))?
     }
 
+    if matches!(parent.kind(), SyntaxKind::BLOCK_EXPR | SyntaxKind::EXPR_STMT) {
+        return acc.add(assist_id, assist_label, target, |builder| {
+            builder.replace(
+                block.syntax().text_range(),
+                update_expr_string(block.to_string(), &[' ', '{', '\n']),
+            );
+        });
+    }
+
     let parent = ast::Expr::cast(parent)?;
 
     match parent.clone() {
@@ -48,7 +58,6 @@ pub(crate) fn unwrap_block(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
                     // For `else if` blocks
                     let ancestor_then_branch = ancestor.then_branch()?;
 
-                    let target = then_branch.syntax().text_range();
                     return acc.add(assist_id, assist_label, target, |edit| {
                         let range_to_del_else_if = TextRange::new(
                             ancestor_then_branch.syntax().text_range().end(),
@@ -68,7 +77,6 @@ pub(crate) fn unwrap_block(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
                     });
                 }
             } else {
-                let target = block.syntax().text_range();
                 return acc.add(assist_id, assist_label, target, |edit| {
                     let range_to_del = TextRange::new(
                         then_branch.syntax().text_range().end(),
@@ -84,7 +92,6 @@ pub(crate) fn unwrap_block(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
     };
 
     let unwrapped = unwrap_trivial_block(block);
-    let target = unwrapped.syntax().text_range();
     acc.add(assist_id, assist_label, target, |builder| {
         builder.replace(
             parent.syntax().text_range(),
@@ -112,31 +119,89 @@ mod tests {
     use super::*;
 
     #[test]
+    fn unwrap_tail_expr_block() {
+        check_assist(
+            unwrap_block,
+            r#"
+fn main() {
+    <|>{
+        92
+    }
+}
+"#,
+            r#"
+fn main() {
+    92
+}
+"#,
+        )
+    }
+
+    #[test]
+    fn unwrap_stmt_expr_block() {
+        check_assist(
+            unwrap_block,
+            r#"
+fn main() {
+    <|>{
+        92;
+    }
+    ()
+}
+"#,
+            r#"
+fn main() {
+    92;
+    ()
+}
+"#,
+        );
+        // Pedantically, we should add an `;` here...
+        check_assist(
+            unwrap_block,
+            r#"
+fn main() {
+    <|>{
+        92
+    }
+    ()
+}
+"#,
+            r#"
+fn main() {
+    92
+    ()
+}
+"#,
+        );
+    }
+
+    #[test]
     fn simple_if() {
         check_assist(
             unwrap_block,
             r#"
-            fn main() {
-                bar();
-                if true {<|>
-                    foo();
-
-                    //comment
-                    bar();
-                } else {
-                    println!("bar");
-                }
-            }
-            "#,
+fn main() {
+    bar();
+    if true {<|>
+        foo();
+
+        //comment
+        bar();
+    } else {
+        println!("bar");
+    }
+}
+"#,
             r#"
-            fn main() {
-                bar();
-                foo();
+fn main() {
+    bar();
+    foo();
 
-                //comment
-                bar();
-            }
-            "#,
+    //comment
+    bar();
+}
+"#,
         );
     }
 
@@ -145,30 +210,30 @@ mod tests {
         check_assist(
             unwrap_block,
             r#"
-            fn main() {
-                bar();
-                if true {
-                    foo();
-
-                    //comment
-                    bar();
-                } else {<|>
-                    println!("bar");
-                }
-            }
-            "#,
+fn main() {
+    bar();
+    if true {
+        foo();
+
+        //comment
+        bar();
+    } else {<|>
+        println!("bar");
+    }
+}
+"#,
             r#"
-            fn main() {
-                bar();
-                if true {
-                    foo();
+fn main() {
+    bar();
+    if true {
+        foo();
 
-                    //comment
-                    bar();
-                }
-                println!("bar");
-            }
-            "#,
+        //comment
+        bar();
+    }
+    println!("bar");
+}
+"#,
         );
     }
 
@@ -177,32 +242,32 @@ mod tests {
         check_assist(
             unwrap_block,
             r#"
-            fn main() {
-                //bar();
-                if true {
-                    println!("true");
-
-                    //comment
-                    //bar();
-                } else if false {<|>
-                    println!("bar");
-                } else {
-                    println!("foo");
-                }
-            }
-            "#,
+fn main() {
+    //bar();
+    if true {
+        println!("true");
+
+        //comment
+        //bar();
+    } else if false {<|>
+        println!("bar");
+    } else {
+        println!("foo");
+    }
+}
+"#,
             r#"
-            fn main() {
-                //bar();
-                if true {
-                    println!("true");
+fn main() {
+    //bar();
+    if true {
+        println!("true");
 
-                    //comment
-                    //bar();
-                }
-                println!("bar");
-            }
-            "#,
+        //comment
+        //bar();
+    }
+    println!("bar");
+}
+"#,
         );
     }
 
@@ -211,34 +276,34 @@ mod tests {
         check_assist(
             unwrap_block,
             r#"
-            fn main() {
-                //bar();
-                if true {
-                    println!("true");
-
-                    //comment
-                    //bar();
-                } else if false {
-                    println!("bar");
-                } else if true {<|>
-                    println!("foo");
-                }
-            }
-            "#,
+fn main() {
+    //bar();
+    if true {
+        println!("true");
+
+        //comment
+        //bar();
+    } else if false {
+        println!("bar");
+    } else if true {<|>
+        println!("foo");
+    }
+}
+"#,
             r#"
-            fn main() {
-                //bar();
-                if true {
-                    println!("true");
-
-                    //comment
-                    //bar();
-                } else if false {
-                    println!("bar");
-                }
-                println!("foo");
-            }
-            "#,
+fn main() {
+    //bar();
+    if true {
+        println!("true");
+
+        //comment
+        //bar();
+    } else if false {
+        println!("bar");
+    }
+    println!("foo");
+}
+"#,
         );
     }
 
@@ -247,38 +312,38 @@ mod tests {
         check_assist(
             unwrap_block,
             r#"
-            fn main() {
-                //bar();
-                if true {
-                    println!("true");
-
-                    //comment
-                    //bar();
-                } else if false {
-                    println!("bar");
-                } else if true {
-                    println!("foo");
-                } else {<|>
-                    println!("else");
-                }
-            }
-            "#,
+fn main() {
+    //bar();
+    if true {
+        println!("true");
+
+        //comment
+        //bar();
+    } else if false {
+        println!("bar");
+    } else if true {
+        println!("foo");
+    } else {<|>
+        println!("else");
+    }
+}
+"#,
             r#"
-            fn main() {
-                //bar();
-                if true {
-                    println!("true");
-
-                    //comment
-                    //bar();
-                } else if false {
-                    println!("bar");
-                } else if true {
-                    println!("foo");
-                }
-                println!("else");
-            }
-            "#,
+fn main() {
+    //bar();
+    if true {
+        println!("true");
+
+        //comment
+        //bar();
+    } else if false {
+        println!("bar");
+    } else if true {
+        println!("foo");
+    }
+    println!("else");
+}
+"#,
         );
     }
 
@@ -287,36 +352,36 @@ mod tests {
         check_assist(
             unwrap_block,
             r#"
-            fn main() {
-                //bar();
-                if true {
-                    println!("true");
-
-                    //comment
-                    //bar();
-                } else if false {
-                    println!("bar");
-                } else if true {<|>
-                    println!("foo");
-                } else {
-                    println!("else");
-                }
-            }
-            "#,
+fn main() {
+    //bar();
+    if true {
+        println!("true");
+
+        //comment
+        //bar();
+    } else if false {
+        println!("bar");
+    } else if true {<|>
+        println!("foo");
+    } else {
+        println!("else");
+    }
+}
+"#,
             r#"
-            fn main() {
-                //bar();
-                if true {
-                    println!("true");
-
-                    //comment
-                    //bar();
-                } else if false {
-                    println!("bar");
-                }
-                println!("foo");
-            }
-            "#,
+fn main() {
+    //bar();
+    if true {
+        println!("true");
+
+        //comment
+        //bar();
+    } else if false {
+        println!("bar");
+    }
+    println!("foo");
+}
+"#,
         );
     }
 
@@ -325,18 +390,18 @@ mod tests {
         check_assist_not_applicable(
             unwrap_block,
             r#"
-            fn main() {
-                bar();<|>
-                if true {
-                    foo();
-
-                    //comment
-                    bar();
-                } else {
-                    println!("bar");
-                }
-            }
-            "#,
+fn main() {
+    bar();<|>
+    if true {
+        foo();
+
+        //comment
+        bar();
+    } else {
+        println!("bar");
+    }
+}
+"#,
         );
     }
 
@@ -345,31 +410,31 @@ mod tests {
         check_assist(
             unwrap_block,
             r#"
-            fn main() {
-                for i in 0..5 {<|>
-                    if true {
-                        foo();
-
-                        //comment
-                        bar();
-                    } else {
-                        println!("bar");
-                    }
-                }
-            }
-            "#,
+fn main() {
+    for i in 0..5 {<|>
+        if true {
+            foo();
+
+            //comment
+            bar();
+        } else {
+            println!("bar");
+        }
+    }
+}
+"#,
             r#"
-            fn main() {
-                if true {
-                    foo();
-
-                    //comment
-                    bar();
-                } else {
-                    println!("bar");
-                }
-            }
-            "#,
+fn main() {
+    if true {
+        foo();
+
+        //comment
+        bar();
+    } else {
+        println!("bar");
+    }
+}
+"#,
         );
     }
 
@@ -378,29 +443,29 @@ mod tests {
         check_assist(
             unwrap_block,
             r#"
-            fn main() {
-                for i in 0..5 {
-                    if true {<|>
-                        foo();
-
-                        //comment
-                        bar();
-                    } else {
-                        println!("bar");
-                    }
-                }
-            }
-            "#,
+fn main() {
+    for i in 0..5 {
+        if true {<|>
+            foo();
+
+            //comment
+            bar();
+        } else {
+            println!("bar");
+        }
+    }
+}
+"#,
             r#"
-            fn main() {
-                for i in 0..5 {
-                    foo();
+fn main() {
+    for i in 0..5 {
+        foo();
 
-                    //comment
-                    bar();
-                }
-            }
-            "#,
+        //comment
+        bar();
+    }
+}
+"#,
         );
     }
 
@@ -409,31 +474,31 @@ mod tests {
         check_assist(
             unwrap_block,
             r#"
-            fn main() {
-                loop {<|>
-                    if true {
-                        foo();
-
-                        //comment
-                        bar();
-                    } else {
-                        println!("bar");
-                    }
-                }
-            }
-            "#,
+fn main() {
+    loop {<|>
+        if true {
+            foo();
+
+            //comment
+            bar();
+        } else {
+            println!("bar");
+        }
+    }
+}
+"#,
             r#"
-            fn main() {
-                if true {
-                    foo();
-
-                    //comment
-                    bar();
-                } else {
-                    println!("bar");
-                }
-            }
-            "#,
+fn main() {
+    if true {
+        foo();
+
+        //comment
+        bar();
+    } else {
+        println!("bar");
+    }
+}
+"#,
         );
     }
 
@@ -442,31 +507,31 @@ mod tests {
         check_assist(
             unwrap_block,
             r#"
-            fn main() {
-                while true {<|>
-                    if true {
-                        foo();
-
-                        //comment
-                        bar();
-                    } else {
-                        println!("bar");
-                    }
-                }
-            }
-            "#,
+fn main() {
+    while true {<|>
+        if true {
+            foo();
+
+            //comment
+            bar();
+        } else {
+            println!("bar");
+        }
+    }
+}
+"#,
             r#"
-            fn main() {
-                if true {
-                    foo();
-
-                    //comment
-                    bar();
-                } else {
-                    println!("bar");
-                }
-            }
-            "#,
+fn main() {
+    if true {
+        foo();
+
+        //comment
+        bar();
+    } else {
+        println!("bar");
+    }
+}
+"#,
         );
     }
 
@@ -499,19 +564,19 @@ fn main() {
         check_assist_not_applicable(
             unwrap_block,
             r#"
-            fn main() {
-                while true {
-                    if true {
-                        foo();<|>
-
-                        //comment
-                        bar();
-                    } else {
-                        println!("bar");
-                    }
-                }
-            }
-            "#,
+fn main() {
+    while true {
+        if true {
+            foo();<|>
+
+            //comment
+            bar();
+        } else {
+            println!("bar");
+        }
+    }
+}
+"#,
         );
     }
 }
diff --git a/crates/assists/src/lib.rs b/crates/assists/src/lib.rs
index e8d81b33d..17e9312db 100644
--- a/crates/assists/src/lib.rs
+++ b/crates/assists/src/lib.rs
@@ -141,6 +141,7 @@ mod handlers {
     mod generate_function;
     mod generate_impl;
     mod generate_new;
+    mod ignore_test;
     mod infer_function_return_type;
     mod inline_local_variable;
     mod introduce_named_lifetime;
@@ -189,6 +190,7 @@ mod handlers {
             generate_function::generate_function,
             generate_impl::generate_impl,
             generate_new::generate_new,
+            ignore_test::ignore_test,
             infer_function_return_type::infer_function_return_type,
             inline_local_variable::inline_local_variable,
             introduce_named_lifetime::introduce_named_lifetime,
diff --git a/crates/assists/src/tests/generated.rs b/crates/assists/src/tests/generated.rs
index dbf4f21aa..5a9d1a01b 100644
--- a/crates/assists/src/tests/generated.rs
+++ b/crates/assists/src/tests/generated.rs
@@ -474,6 +474,26 @@ impl<T: Clone> Ctx<T> {
 }
 
 #[test]
+fn doctest_ignore_test() {
+    check_doc_test(
+        "ignore_test",
+        r#####"
+<|>#[test]
+fn arithmetics {
+    assert_eq!(2 + 2, 5);
+}
+"#####,
+        r#####"
+#[test]
+#[ignore]
+fn arithmetics {
+    assert_eq!(2 + 2, 5);
+}
+"#####,
+    )
+}
+
+#[test]
 fn doctest_infer_function_return_type() {
     check_doc_test(
         "infer_function_return_type",
diff --git a/crates/assists/src/utils.rs b/crates/assists/src/utils.rs
index 7bd338e99..d1a0a99b1 100644
--- a/crates/assists/src/utils.rs
+++ b/crates/assists/src/utils.rs
@@ -9,6 +9,7 @@ use ide_db::RootDatabase;
 use itertools::Itertools;
 use syntax::{
     ast::edit::AstNodeEdit,
+    ast::AttrsOwner,
     ast::NameOwner,
     ast::{self, edit, make, ArgListOwner},
     AstNode, Direction,
@@ -82,6 +83,23 @@ pub fn extract_trivial_expression(block: &ast::BlockExpr) -> Option<ast::Expr> {
     None
 }
 
+/// This is a method with a heuristics to support test methods annotated with custom test annotations, such as
+/// `#[test_case(...)]`, `#[tokio::test]` and similar.
+/// Also a regular `#[test]` annotation is supported.
+///
+/// It may produce false positives, for example, `#[wasm_bindgen_test]` requires a different command to run the test,
+/// but it's better than not to have the runnables for the tests at all.
+pub fn test_related_attribute(fn_def: &ast::Fn) -> Option<ast::Attr> {
+    fn_def.attrs().find_map(|attr| {
+        let path = attr.path()?;
+        if path.syntax().text().to_string().contains("test") {
+            Some(attr)
+        } else {
+            None
+        }
+    })
+}
+
 #[derive(Copy, Clone, PartialEq)]
 pub enum DefaultMethods {
     Only,
diff --git a/crates/base_db/src/input.rs b/crates/base_db/src/input.rs
index 31907ed98..98ba372ad 100644
--- a/crates/base_db/src/input.rs
+++ b/crates/base_db/src/input.rs
@@ -225,7 +225,10 @@ impl CrateGraph {
         to: CrateId,
     ) -> Result<(), CyclicDependenciesError> {
         if self.dfs_find(from, to, &mut FxHashSet::default()) {
-            return Err(CyclicDependenciesError);
+            return Err(CyclicDependenciesError {
+                from: (from, self[from].display_name.clone()),
+                to: (to, self[to].display_name.clone()),
+            });
         }
         self.arena.get_mut(&from).unwrap().add_dep(name, to);
         Ok(())
@@ -421,7 +424,20 @@ impl fmt::Display for ParseEditionError {
 impl std::error::Error for ParseEditionError {}
 
 #[derive(Debug)]
-pub struct CyclicDependenciesError;
+pub struct CyclicDependenciesError {
+    from: (CrateId, Option<CrateDisplayName>),
+    to: (CrateId, Option<CrateDisplayName>),
+}
+
+impl fmt::Display for CyclicDependenciesError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let render = |(id, name): &(CrateId, Option<CrateDisplayName>)| match name {
+            Some(it) => format!("{}({:?})", it, id),
+            None => format!("{:?}", id),
+        };
+        write!(f, "cyclic deps: {} -> {}", render(&self.from), render(&self.to))
+    }
+}
 
 #[cfg(test)]
 mod tests {
diff --git a/crates/cfg/src/lib.rs b/crates/cfg/src/lib.rs
index d0e08cf5f..d88ecf8b0 100644
--- a/crates/cfg/src/lib.rs
+++ b/crates/cfg/src/lib.rs
@@ -41,12 +41,6 @@ impl CfgOptions {
         self.enabled.insert(CfgAtom::KeyValue { key, value });
     }
 
-    pub fn append(&mut self, other: &CfgOptions) {
-        for atom in &other.enabled {
-            self.enabled.insert(atom.clone());
-        }
-    }
-
     pub fn apply_diff(&mut self, diff: CfgDiff) {
         for atom in diff.enable {
             self.enabled.insert(atom);
diff --git a/crates/ide/src/fn_references.rs b/crates/ide/src/fn_references.rs
index 459f201ed..5cbbe306e 100644
--- a/crates/ide/src/fn_references.rs
+++ b/crates/ide/src/fn_references.rs
@@ -1,11 +1,12 @@
 //! This module implements a methods and free functions search in the specified file.
 //! We have to skip tests, so cannot reuse file_structure module.
 
+use assists::utils::test_related_attribute;
 use hir::Semantics;
 use ide_db::RootDatabase;
 use syntax::{ast, ast::NameOwner, AstNode, SyntaxNode};
 
-use crate::{runnables::has_test_related_attribute, FileId, FileRange};
+use crate::{FileId, FileRange};
 
 pub(crate) fn find_all_methods(db: &RootDatabase, file_id: FileId) -> Vec<FileRange> {
     let sema = Semantics::new(db);
@@ -15,7 +16,7 @@ pub(crate) fn find_all_methods(db: &RootDatabase, file_id: FileId) -> Vec<FileRa
 
 fn method_range(item: SyntaxNode, file_id: FileId) -> Option<FileRange> {
     ast::Fn::cast(item).and_then(|fn_def| {
-        if has_test_related_attribute(&fn_def) {
+        if test_related_attribute(&fn_def).is_some() {
             None
         } else {
             fn_def.name().map(|name| FileRange { file_id, range: name.syntax().text_range() })
diff --git a/crates/ide/src/runnables.rs b/crates/ide/src/runnables.rs
index 2bd0e86e5..e15411777 100644
--- a/crates/ide/src/runnables.rs
+++ b/crates/ide/src/runnables.rs
@@ -1,5 +1,6 @@
 use std::fmt;
 
+use assists::utils::test_related_attribute;
 use cfg::CfgExpr;
 use hir::{AsAssocItem, Attrs, HirFileId, InFile, Semantics};
 use ide_db::RootDatabase;
@@ -156,7 +157,7 @@ fn runnable_fn(
             None => TestId::Name(name_string),
         };
 
-        if has_test_related_attribute(&fn_def) {
+        if test_related_attribute(&fn_def).is_some() {
             let attr = TestAttr::from_fn(&fn_def);
             RunnableKind::Test { test_id, attr }
         } else if fn_def.has_atom_attr("bench") {
@@ -235,20 +236,6 @@ impl TestAttr {
     }
 }
 
-/// This is a method with a heuristics to support test methods annotated with custom test annotations, such as
-/// `#[test_case(...)]`, `#[tokio::test]` and similar.
-/// Also a regular `#[test]` annotation is supported.
-///
-/// It may produce false positives, for example, `#[wasm_bindgen_test]` requires a different command to run the test,
-/// but it's better than not to have the runnables for the tests at all.
-pub(crate) fn has_test_related_attribute(fn_def: &ast::Fn) -> bool {
-    fn_def
-        .attrs()
-        .filter_map(|attr| attr.path())
-        .map(|path| path.syntax().to_string().to_lowercase())
-        .any(|attribute_text| attribute_text.contains("test"))
-}
-
 const RUSTDOC_FENCE: &str = "```";
 const RUSTDOC_CODE_BLOCK_ATTRIBUTES_RUNNABLE: &[&str] =
     &["", "rust", "should_panic", "edition2015", "edition2018"];
@@ -307,7 +294,7 @@ fn has_test_function_or_multiple_test_submodules(module: &ast::Module) -> bool {
         for item in item_list.items() {
             match item {
                 ast::Item::Fn(f) => {
-                    if has_test_related_attribute(&f) {
+                    if test_related_attribute(&f).is_some() {
                         return true;
                     }
                 }
diff --git a/crates/project_model/src/sysroot.rs b/crates/project_model/src/sysroot.rs
index b0e8863f6..f0a43eaf6 100644
--- a/crates/project_model/src/sysroot.rs
+++ b/crates/project_model/src/sysroot.rs
@@ -37,7 +37,7 @@ impl Sysroot {
     pub fn public_deps(&self) -> impl Iterator<Item = (&'static str, SysrootCrate)> + '_ {
         // core is added as a dependency before std in order to
         // mimic rustcs dependency order
-        vec!["core", "alloc", "std"].into_iter().filter_map(move |it| Some((it, self.by_name(it)?)))
+        ["core", "alloc", "std"].iter().filter_map(move |&it| Some((it, self.by_name(it)?)))
     }
 
     pub fn proc_macro(&self) -> Option<SysrootCrate> {
diff --git a/crates/project_model/src/workspace.rs b/crates/project_model/src/workspace.rs
index 9ebb0a811..a71f96164 100644
--- a/crates/project_model/src/workspace.rs
+++ b/crates/project_model/src/workspace.rs
@@ -12,8 +12,8 @@ use proc_macro_api::ProcMacroClient;
 use rustc_hash::{FxHashMap, FxHashSet};
 
 use crate::{
-    cargo_workspace, cfg_flag::CfgFlag, utf8_stdout, CargoConfig, CargoWorkspace, ProjectJson,
-    ProjectManifest, Sysroot, TargetKind,
+    cargo_workspace, cfg_flag::CfgFlag, sysroot::SysrootCrate, utf8_stdout, CargoConfig,
+    CargoWorkspace, ProjectJson, ProjectManifest, Sysroot, TargetKind,
 };
 
 /// `PackageRoot` describes a package root folder.
@@ -70,12 +70,8 @@ impl ProjectWorkspace {
                     format!("Failed to deserialize json file {}", project_json.display())
                 })?;
                 let project_location = project_json.parent().unwrap().to_path_buf();
-                let project = ProjectJson::new(&project_location, data);
-                let sysroot = match &project.sysroot_src {
-                    Some(path) => Some(Sysroot::load(path)?),
-                    None => None,
-                };
-                ProjectWorkspace::Json { project, sysroot }
+                let project_json = ProjectJson::new(&project_location, data);
+                ProjectWorkspace::load_inline(project_json)?
             }
             ProjectManifest::CargoToml(cargo_toml) => {
                 let cargo_version = utf8_stdout({
@@ -150,43 +146,38 @@ impl ProjectWorkspace {
                     })
                 }))
                 .collect::<Vec<_>>(),
-            ProjectWorkspace::Cargo { cargo, sysroot, rustc } => {
-                let roots = cargo
-                    .packages()
-                    .map(|pkg| {
-                        let is_member = cargo[pkg].is_member;
-                        let pkg_root = cargo[pkg].root().to_path_buf();
-
-                        let mut include = vec![pkg_root.clone()];
-                        include.extend(cargo[pkg].out_dir.clone());
-
-                        let mut exclude = vec![pkg_root.join(".git")];
-                        if is_member {
-                            exclude.push(pkg_root.join("target"));
-                        } else {
-                            exclude.push(pkg_root.join("tests"));
-                            exclude.push(pkg_root.join("examples"));
-                            exclude.push(pkg_root.join("benches"));
-                        }
-                        PackageRoot { is_member, include, exclude }
-                    })
-                    .chain(sysroot.crates().map(|krate| PackageRoot {
+            ProjectWorkspace::Cargo { cargo, sysroot, rustc } => cargo
+                .packages()
+                .map(|pkg| {
+                    let is_member = cargo[pkg].is_member;
+                    let pkg_root = cargo[pkg].root().to_path_buf();
+
+                    let mut include = vec![pkg_root.clone()];
+                    include.extend(cargo[pkg].out_dir.clone());
+
+                    let mut exclude = vec![pkg_root.join(".git")];
+                    if is_member {
+                        exclude.push(pkg_root.join("target"));
+                    } else {
+                        exclude.push(pkg_root.join("tests"));
+                        exclude.push(pkg_root.join("examples"));
+                        exclude.push(pkg_root.join("benches"));
+                    }
+                    PackageRoot { is_member, include, exclude }
+                })
+                .chain(sysroot.crates().map(|krate| PackageRoot {
+                    is_member: false,
+                    include: vec![sysroot[krate].root_dir().to_path_buf()],
+                    exclude: Vec::new(),
+                }))
+                .chain(rustc.into_iter().flat_map(|rustc| {
+                    rustc.packages().map(move |krate| PackageRoot {
                         is_member: false,
-                        include: vec![sysroot[krate].root_dir().to_path_buf()],
+                        include: vec![rustc[krate].root().to_path_buf()],
                         exclude: Vec::new(),
-                    }));
-                if let Some(rustc_packages) = rustc {
-                    roots
-                        .chain(rustc_packages.packages().map(|krate| PackageRoot {
-                            is_member: false,
-                            include: vec![rustc_packages[krate].root().to_path_buf()],
-                            exclude: Vec::new(),
-                        }))
-                        .collect()
-                } else {
-                    roots.collect()
-                }
-            }
+                    })
+                }))
+                .collect(),
         }
     }
 
@@ -206,312 +197,280 @@ impl ProjectWorkspace {
         proc_macro_client: &ProcMacroClient,
         load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
     ) -> CrateGraph {
-        let mut crate_graph = CrateGraph::default();
-        match self {
+        let mut crate_graph = match self {
             ProjectWorkspace::Json { project, sysroot } => {
-                let sysroot_dps = sysroot
-                    .as_ref()
-                    .map(|sysroot| sysroot_to_crate_graph(&mut crate_graph, sysroot, target, load));
-
-                let mut cfg_cache: FxHashMap<Option<&str>, Vec<CfgFlag>> = FxHashMap::default();
-                let crates: FxHashMap<_, _> = project
-                    .crates()
-                    .filter_map(|(crate_id, krate)| {
-                        let file_path = &krate.root_module;
-                        let file_id = match load(&file_path) {
-                            Some(id) => id,
-                            None => {
-                                log::error!("failed to load crate root {}", file_path.display());
-                                return None;
-                            }
-                        };
-
-                        let env = krate.env.clone().into_iter().collect();
-                        let proc_macro = krate
-                            .proc_macro_dylib_path
-                            .clone()
-                            .map(|it| proc_macro_client.by_dylib_path(&it));
-
-                        let target = krate.target.as_deref().or(target);
-                        let target_cfgs = cfg_cache
-                            .entry(target)
-                            .or_insert_with(|| get_rustc_cfg_options(target));
-
-                        let mut cfg_options = CfgOptions::default();
-                        cfg_options.extend(target_cfgs.iter().chain(krate.cfg.iter()).cloned());
-
-                        Some((
-                            crate_id,
-                            crate_graph.add_crate_root(
-                                file_id,
-                                krate.edition,
-                                krate.display_name.clone(),
-                                cfg_options,
-                                env,
-                                proc_macro.unwrap_or_default(),
-                            ),
-                        ))
-                    })
-                    .collect();
-
-                for (from, krate) in project.crates() {
-                    if let Some(&from) = crates.get(&from) {
-                        if let Some((public_deps, _proc_macro)) = &sysroot_dps {
-                            for (name, to) in public_deps.iter() {
-                                if let Err(_) = crate_graph.add_dep(from, name.clone(), *to) {
-                                    log::error!("cyclic dependency on {} for {:?}", name, from)
-                                }
-                            }
-                        }
-
-                        for dep in &krate.deps {
-                            let to_crate_id = dep.crate_id;
-                            if let Some(&to) = crates.get(&to_crate_id) {
-                                if let Err(_) = crate_graph.add_dep(from, dep.name.clone(), to) {
-                                    log::error!("cyclic dependency {:?} -> {:?}", from, to);
-                                }
-                            }
-                        }
-                    }
-                }
+                project_json_to_crate_graph(target, proc_macro_client, load, project, sysroot)
             }
             ProjectWorkspace::Cargo { cargo, sysroot, rustc } => {
-                let (public_deps, libproc_macro) =
-                    sysroot_to_crate_graph(&mut crate_graph, sysroot, target, load);
+                cargo_to_crate_graph(target, proc_macro_client, load, cargo, sysroot, rustc)
+            }
+        };
+        if crate_graph.patch_cfg_if() {
+            log::debug!("Patched std to depend on cfg-if")
+        } else {
+            log::debug!("Did not patch std to depend on cfg-if")
+        }
+        crate_graph
+    }
+}
+
+fn project_json_to_crate_graph(
+    target: Option<&str>,
+    proc_macro_client: &ProcMacroClient,
+    load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
+    project: &ProjectJson,
+    sysroot: &Option<Sysroot>,
+) -> CrateGraph {
+    let mut crate_graph = CrateGraph::default();
+    let sysroot_deps = sysroot
+        .as_ref()
+        .map(|sysroot| sysroot_to_crate_graph(&mut crate_graph, sysroot, target, load));
+
+    let mut cfg_cache: FxHashMap<Option<&str>, Vec<CfgFlag>> = FxHashMap::default();
+    let crates: FxHashMap<CrateId, CrateId> = project
+        .crates()
+        .filter_map(|(crate_id, krate)| {
+            let file_path = &krate.root_module;
+            let file_id = load(&file_path)?;
+            Some((crate_id, krate, file_id))
+        })
+        .map(|(crate_id, krate, file_id)| {
+            let env = krate.env.clone().into_iter().collect();
+            let proc_macro =
+                krate.proc_macro_dylib_path.clone().map(|it| proc_macro_client.by_dylib_path(&it));
+
+            let target = krate.target.as_deref().or(target);
+            let target_cfgs =
+                cfg_cache.entry(target).or_insert_with(|| get_rustc_cfg_options(target));
+
+            let mut cfg_options = CfgOptions::default();
+            cfg_options.extend(target_cfgs.iter().chain(krate.cfg.iter()).cloned());
+            (
+                crate_id,
+                crate_graph.add_crate_root(
+                    file_id,
+                    krate.edition,
+                    krate.display_name.clone(),
+                    cfg_options,
+                    env,
+                    proc_macro.unwrap_or_default(),
+                ),
+            )
+        })
+        .collect();
 
-                let mut cfg_options = CfgOptions::default();
-                cfg_options.extend(get_rustc_cfg_options(target));
+    for (from, krate) in project.crates() {
+        if let Some(&from) = crates.get(&from) {
+            if let Some((public_deps, _proc_macro)) = &sysroot_deps {
+                for (name, to) in public_deps.iter() {
+                    add_dep(&mut crate_graph, from, name.clone(), *to)
+                }
+            }
 
-                let mut pkg_to_lib_crate = FxHashMap::default();
+            for dep in &krate.deps {
+                if let Some(&to) = crates.get(&dep.crate_id) {
+                    add_dep(&mut crate_graph, from, dep.name.clone(), to)
+                }
+            }
+        }
+    }
+    crate_graph
+}
 
-                // Add test cfg for non-sysroot crates
-                cfg_options.insert_atom("test".into());
-                cfg_options.insert_atom("debug_assertions".into());
+fn cargo_to_crate_graph(
+    target: Option<&str>,
+    proc_macro_client: &ProcMacroClient,
+    load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
+    cargo: &CargoWorkspace,
+    sysroot: &Sysroot,
+    rustc: &Option<CargoWorkspace>,
+) -> CrateGraph {
+    let mut crate_graph = CrateGraph::default();
+    let (public_deps, libproc_macro) =
+        sysroot_to_crate_graph(&mut crate_graph, sysroot, target, load);
 
-                let mut pkg_crates = FxHashMap::default();
+    let mut cfg_options = CfgOptions::default();
+    cfg_options.extend(get_rustc_cfg_options(target));
 
-                // Next, create crates for each package, target pair
-                for pkg in cargo.packages() {
-                    let mut lib_tgt = None;
-                    for &tgt in cargo[pkg].targets.iter() {
-                        if let Some(crate_id) = add_target_crate_root(
+    let mut pkg_to_lib_crate = FxHashMap::default();
+
+    // Add test cfg for non-sysroot crates
+    cfg_options.insert_atom("test".into());
+    cfg_options.insert_atom("debug_assertions".into());
+
+    let mut pkg_crates = FxHashMap::default();
+
+    // Next, create crates for each package, target pair
+    for pkg in cargo.packages() {
+        let mut lib_tgt = None;
+        for &tgt in cargo[pkg].targets.iter() {
+            if let Some(file_id) = load(&cargo[tgt].root) {
+                let crate_id = add_target_crate_root(
+                    &mut crate_graph,
+                    &cargo[pkg],
+                    &cfg_options,
+                    proc_macro_client,
+                    file_id,
+                );
+                if cargo[tgt].kind == TargetKind::Lib {
+                    lib_tgt = Some((crate_id, cargo[tgt].name.clone()));
+                    pkg_to_lib_crate.insert(pkg, crate_id);
+                }
+                if cargo[tgt].is_proc_macro {
+                    if let Some(proc_macro) = libproc_macro {
+                        add_dep(
                             &mut crate_graph,
-                            &cargo[pkg],
-                            &cargo[tgt],
-                            &cfg_options,
-                            proc_macro_client,
-                            load,
-                        ) {
-                            if cargo[tgt].kind == TargetKind::Lib {
-                                lib_tgt = Some((crate_id, cargo[tgt].name.clone()));
-                                pkg_to_lib_crate.insert(pkg, crate_id);
-                            }
-                            if cargo[tgt].is_proc_macro {
-                                if let Some(proc_macro) = libproc_macro {
-                                    if let Err(_) = crate_graph.add_dep(
-                                        crate_id,
-                                        CrateName::new("proc_macro").unwrap(),
-                                        proc_macro,
-                                    ) {
-                                        log::error!(
-                                            "cyclic dependency on proc_macro for {}",
-                                            &cargo[pkg].name
-                                        )
-                                    }
-                                }
-                            }
-
-                            pkg_crates.entry(pkg).or_insert_with(Vec::new).push(crate_id);
-                        }
+                            crate_id,
+                            CrateName::new("proc_macro").unwrap(),
+                            proc_macro,
+                        );
                     }
+                }
 
-                    // Set deps to the core, std and to the lib target of the current package
-                    for &from in pkg_crates.get(&pkg).into_iter().flatten() {
-                        if let Some((to, name)) = lib_tgt.clone() {
-                            // For root projects with dashes in their name,
-                            // cargo metadata does not do any normalization,
-                            // so we do it ourselves currently
-                            let name = CrateName::normalize_dashes(&name);
-                            if to != from && crate_graph.add_dep(from, name, to).is_err() {
-                                log::error!(
-                                    "cyclic dependency between targets of {}",
-                                    &cargo[pkg].name
-                                )
-                            }
-                        }
-                        for (name, krate) in public_deps.iter() {
-                            if let Err(_) = crate_graph.add_dep(from, name.clone(), *krate) {
-                                log::error!(
-                                    "cyclic dependency on {} for {}",
-                                    name,
-                                    &cargo[pkg].name
-                                )
-                            }
-                        }
-                    }
+                pkg_crates.entry(pkg).or_insert_with(Vec::new).push(crate_id);
+            }
+        }
+
+        // Set deps to the core, std and to the lib target of the current package
+        for &from in pkg_crates.get(&pkg).into_iter().flatten() {
+            if let Some((to, name)) = lib_tgt.clone() {
+                if to != from {
+                    // For root projects with dashes in their name,
+                    // cargo metadata does not do any normalization,
+                    // so we do it ourselves currently
+                    let name = CrateName::normalize_dashes(&name);
+                    add_dep(&mut crate_graph, from, name, to);
+                }
+            }
+            for (name, krate) in public_deps.iter() {
+                add_dep(&mut crate_graph, from, name.clone(), *krate);
+            }
+        }
+    }
+
+    // Now add a dep edge from all targets of upstream to the lib
+    // target of downstream.
+    for pkg in cargo.packages() {
+        for dep in cargo[pkg].dependencies.iter() {
+            let name = CrateName::new(&dep.name).unwrap();
+            if let Some(&to) = pkg_to_lib_crate.get(&dep.pkg) {
+                for &from in pkg_crates.get(&pkg).into_iter().flatten() {
+                    add_dep(&mut crate_graph, from, name.clone(), to)
                 }
+            }
+        }
+    }
 
-                // Now add a dep edge from all targets of upstream to the lib
-                // target of downstream.
-                for pkg in cargo.packages() {
-                    for dep in cargo[pkg].dependencies.iter() {
-                        let name = CrateName::new(&dep.name).unwrap();
-                        if let Some(&to) = pkg_to_lib_crate.get(&dep.pkg) {
-                            for &from in pkg_crates.get(&pkg).into_iter().flatten() {
-                                if let Err(_) = crate_graph.add_dep(from, name.clone(), to) {
-                                    log::error!(
-                                        "cyclic dependency {} -> {}",
-                                        &cargo[pkg].name,
-                                        &cargo[dep.pkg].name
-                                    )
-                                }
-                            }
-                        }
-                    }
+    let mut rustc_pkg_crates = FxHashMap::default();
+
+    // If the user provided a path to rustc sources, we add all the rustc_private crates
+    // and create dependencies on them for the crates in the current workspace
+    if let Some(rustc_workspace) = rustc {
+        for pkg in rustc_workspace.packages() {
+            for &tgt in rustc_workspace[pkg].targets.iter() {
+                if rustc_workspace[tgt].kind != TargetKind::Lib {
+                    continue;
+                }
+                // Exclude alloc / core / std
+                if rustc_workspace[tgt]
+                    .root
+                    .components()
+                    .any(|c| c == Component::Normal("library".as_ref()))
+                {
+                    continue;
                 }
 
-                let mut rustc_pkg_crates = FxHashMap::default();
-
-                // If the user provided a path to rustc sources, we add all the rustc_private crates
-                // and create dependencies on them for the crates in the current workspace
-                if let Some(rustc_workspace) = rustc {
-                    for pkg in rustc_workspace.packages() {
-                        for &tgt in rustc_workspace[pkg].targets.iter() {
-                            if rustc_workspace[tgt].kind != TargetKind::Lib {
-                                continue;
-                            }
-                            // Exclude alloc / core / std
-                            if rustc_workspace[tgt]
-                                .root
-                                .components()
-                                .any(|c| c == Component::Normal("library".as_ref()))
-                            {
-                                continue;
-                            }
-
-                            if let Some(crate_id) = add_target_crate_root(
-                                &mut crate_graph,
-                                &rustc_workspace[pkg],
-                                &rustc_workspace[tgt],
-                                &cfg_options,
-                                proc_macro_client,
-                                load,
-                            ) {
-                                pkg_to_lib_crate.insert(pkg, crate_id);
-                                // Add dependencies on the core / std / alloc for rustc
-                                for (name, krate) in public_deps.iter() {
-                                    if let Err(_) =
-                                        crate_graph.add_dep(crate_id, name.clone(), *krate)
-                                    {
-                                        log::error!(
-                                            "cyclic dependency on {} for {}",
-                                            name,
-                                            &cargo[pkg].name
-                                        )
-                                    }
-                                }
-                                rustc_pkg_crates.entry(pkg).or_insert_with(Vec::new).push(crate_id);
-                            }
-                        }
+                if let Some(file_id) = load(&rustc_workspace[tgt].root) {
+                    let crate_id = add_target_crate_root(
+                        &mut crate_graph,
+                        &rustc_workspace[pkg],
+                        &cfg_options,
+                        proc_macro_client,
+                        file_id,
+                    );
+                    pkg_to_lib_crate.insert(pkg, crate_id);
+                    // Add dependencies on the core / std / alloc for rustc
+                    for (name, krate) in public_deps.iter() {
+                        add_dep(&mut crate_graph, crate_id, name.clone(), *krate);
                     }
-                    // Now add a dep edge from all targets of upstream to the lib
-                    // target of downstream.
-                    for pkg in rustc_workspace.packages() {
-                        for dep in rustc_workspace[pkg].dependencies.iter() {
-                            let name = CrateName::new(&dep.name).unwrap();
-                            if let Some(&to) = pkg_to_lib_crate.get(&dep.pkg) {
-                                for &from in rustc_pkg_crates.get(&pkg).into_iter().flatten() {
-                                    if let Err(_) = crate_graph.add_dep(from, name.clone(), to) {
-                                        log::error!(
-                                            "cyclic dependency {} -> {}",
-                                            &rustc_workspace[pkg].name,
-                                            &rustc_workspace[dep.pkg].name
-                                        )
-                                    }
-                                }
-                            }
-                        }
+                    rustc_pkg_crates.entry(pkg).or_insert_with(Vec::new).push(crate_id);
+                }
+            }
+        }
+        // Now add a dep edge from all targets of upstream to the lib
+        // target of downstream.
+        for pkg in rustc_workspace.packages() {
+            for dep in rustc_workspace[pkg].dependencies.iter() {
+                let name = CrateName::new(&dep.name).unwrap();
+                if let Some(&to) = pkg_to_lib_crate.get(&dep.pkg) {
+                    for &from in rustc_pkg_crates.get(&pkg).into_iter().flatten() {
+                        add_dep(&mut crate_graph, from, name.clone(), to);
                     }
+                }
+            }
+        }
 
-                    // Add dependencies for all the crates of the current workspace to rustc_private libraries
-                    for dep in rustc_workspace.packages() {
-                        let name = CrateName::normalize_dashes(&rustc_workspace[dep].name);
-
-                        if let Some(&to) = pkg_to_lib_crate.get(&dep) {
-                            for pkg in cargo.packages() {
-                                if !cargo[pkg].is_member {
-                                    continue;
-                                }
-                                for &from in pkg_crates.get(&pkg).into_iter().flatten() {
-                                    if let Err(_) = crate_graph.add_dep(from, name.clone(), to) {
-                                        log::error!(
-                                            "cyclic dependency {} -> {}",
-                                            &cargo[pkg].name,
-                                            &rustc_workspace[dep].name
-                                        )
-                                    }
-                                }
-                            }
-                        }
+        // Add dependencies for all the crates of the current workspace to rustc_private libraries
+        for dep in rustc_workspace.packages() {
+            let name = CrateName::normalize_dashes(&rustc_workspace[dep].name);
+
+            if let Some(&to) = pkg_to_lib_crate.get(&dep) {
+                for pkg in cargo.packages() {
+                    if !cargo[pkg].is_member {
+                        continue;
+                    }
+                    for &from in pkg_crates.get(&pkg).into_iter().flatten() {
+                        add_dep(&mut crate_graph, from, name.clone(), to);
                     }
                 }
             }
         }
-        if crate_graph.patch_cfg_if() {
-            log::debug!("Patched std to depend on cfg-if")
-        } else {
-            log::debug!("Did not patch std to depend on cfg-if")
-        }
-        crate_graph
     }
+    crate_graph
 }
 
 fn add_target_crate_root(
     crate_graph: &mut CrateGraph,
     pkg: &cargo_workspace::PackageData,
-    tgt: &cargo_workspace::TargetData,
     cfg_options: &CfgOptions,
     proc_macro_client: &ProcMacroClient,
-    load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
-) -> Option<CrateId> {
-    let root = tgt.root.as_path();
-    if let Some(file_id) = load(root) {
-        let edition = pkg.edition;
-        let cfg_options = {
-            let mut opts = cfg_options.clone();
-            for feature in pkg.features.iter() {
-                opts.insert_key_value("feature".into(), feature.into());
-            }
-            opts.extend(pkg.cfgs.iter().cloned());
-            opts
-        };
-        let mut env = Env::default();
-        if let Some(out_dir) = &pkg.out_dir {
-            // NOTE: cargo and rustc seem to hide non-UTF-8 strings from env! and option_env!()
-            if let Some(out_dir) = out_dir.to_str().map(|s| s.to_owned()) {
-                env.set("OUT_DIR", out_dir);
-            }
+    file_id: FileId,
+) -> CrateId {
+    let edition = pkg.edition;
+    let cfg_options = {
+        let mut opts = cfg_options.clone();
+        for feature in pkg.features.iter() {
+            opts.insert_key_value("feature".into(), feature.into());
+        }
+        opts.extend(pkg.cfgs.iter().cloned());
+        opts
+    };
+    let mut env = Env::default();
+    if let Some(out_dir) = &pkg.out_dir {
+        // NOTE: cargo and rustc seem to hide non-UTF-8 strings from env! and option_env!()
+        if let Some(out_dir) = out_dir.to_str().map(|s| s.to_owned()) {
+            env.set("OUT_DIR", out_dir);
         }
-        let proc_macro = pkg
-            .proc_macro_dylib_path
-            .as_ref()
-            .map(|it| proc_macro_client.by_dylib_path(&it))
-            .unwrap_or_default();
-
-        let display_name = CrateDisplayName::from_canonical_name(pkg.name.clone());
-        let crate_id = crate_graph.add_crate_root(
-            file_id,
-            edition,
-            Some(display_name),
-            cfg_options,
-            env,
-            proc_macro.clone(),
-        );
-
-        return Some(crate_id);
     }
-    None
+    let proc_macro = pkg
+        .proc_macro_dylib_path
+        .as_ref()
+        .map(|it| proc_macro_client.by_dylib_path(&it))
+        .unwrap_or_default();
+
+    let display_name = CrateDisplayName::from_canonical_name(pkg.name.clone());
+    let crate_id = crate_graph.add_crate_root(
+        file_id,
+        edition,
+        Some(display_name),
+        cfg_options,
+        env,
+        proc_macro.clone(),
+    );
+
+    crate_id
 }
+
 fn sysroot_to_crate_graph(
     crate_graph: &mut CrateGraph,
     sysroot: &Sysroot,
@@ -520,19 +479,18 @@ fn sysroot_to_crate_graph(
 ) -> (Vec<(CrateName, CrateId)>, Option<CrateId>) {
     let mut cfg_options = CfgOptions::default();
     cfg_options.extend(get_rustc_cfg_options(target));
-    let sysroot_crates: FxHashMap<_, _> = sysroot
+    let sysroot_crates: FxHashMap<SysrootCrate, CrateId> = sysroot
         .crates()
         .filter_map(|krate| {
             let file_id = load(&sysroot[krate].root)?;
 
             let env = Env::default();
             let proc_macro = vec![];
-            let name = CrateName::new(&sysroot[krate].name)
-                .expect("Sysroot crates' names do not contain dashes");
+            let display_name = CrateDisplayName::from_canonical_name(sysroot[krate].name.clone());
             let crate_id = crate_graph.add_crate_root(
                 file_id,
                 Edition::Edition2018,
-                Some(name.into()),
+                Some(display_name),
                 cfg_options.clone(),
                 env,
                 proc_macro,
@@ -545,9 +503,7 @@ fn sysroot_to_crate_graph(
         for &to in sysroot[from].deps.iter() {
             let name = CrateName::new(&sysroot[to].name).unwrap();
             if let (Some(&from), Some(&to)) = (sysroot_crates.get(&from), sysroot_crates.get(&to)) {
-                if let Err(_) = crate_graph.add_dep(from, name, to) {
-                    log::error!("cyclic dependency between sysroot crates")
-                }
+                add_dep(crate_graph, from, name, to);
             }
         }
     }
@@ -588,3 +544,9 @@ fn get_rustc_cfg_options(target: Option<&str>) -> Vec<CfgFlag> {
 
     res
 }
+
+fn add_dep(graph: &mut CrateGraph, from: CrateId, name: CrateName, to: CrateId) {
+    if let Err(err) = graph.add_dep(from, name, to) {
+        log::error!("{}", err)
+    }
+}
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index d25c4bf83..56c51486f 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -21,7 +21,7 @@ env_logger = { version = "0.8.1", default-features = false }
 itertools = "0.9.0"
 jod-thread = "0.1.0"
 log = "0.4.8"
-lsp-types = { version = "0.83.0", features = ["proposed"] }
+lsp-types = { version = "0.83.1", features = ["proposed"] }
 parking_lot = "0.11.0"
 pico-args = "0.3.1"
 oorandom = "11.1.2"
@@ -31,7 +31,7 @@ serde_json = "1.0.48"
 threadpool = "1.7.1"
 rayon = "1.5"
 mimalloc = { version = "0.1.19", default-features = false, optional = true }
-lsp-server = "0.4.0"
+lsp-server = "0.5.0"
 tracing = "0.1"
 tracing-subscriber = { version = "0.2", default-features = false, features = ["env-filter", "registry"] }
 tracing-tree = { version = "0.1.4" }
diff --git a/crates/rust-analyzer/src/caps.rs b/crates/rust-analyzer/src/caps.rs
index 9a8870053..c7203451c 100644
--- a/crates/rust-analyzer/src/caps.rs
+++ b/crates/rust-analyzer/src/caps.rs
@@ -62,6 +62,7 @@ pub fn server_capabilities(client_caps: &ClientCapabilities) -> ServerCapabiliti
             prepare_provider: Some(true),
             work_done_progress_options: WorkDoneProgressOptions { work_done_progress: None },
         })),
+        on_type_rename_provider: None,
         document_link_provider: None,
         color_provider: None,
         execute_command_provider: None,
diff --git a/crates/rust-analyzer/src/diagnostics/to_proto.rs b/crates/rust-analyzer/src/diagnostics/to_proto.rs
index 15145415b..93bef5c8b 100644
--- a/crates/rust-analyzer/src/diagnostics/to_proto.rs
+++ b/crates/rust-analyzer/src/diagnostics/to_proto.rs
@@ -55,8 +55,8 @@ fn location_naive(workspace_root: &Path, span: &DiagnosticSpan) -> lsp_types::Lo
 
     // FIXME: this doesn't handle UTF16 offsets correctly
     let range = lsp_types::Range::new(
-        lsp_types::Position::new(span.line_start as u64 - 1, span.column_start as u64 - 1),
-        lsp_types::Position::new(span.line_end as u64 - 1, span.column_end as u64 - 1),
+        lsp_types::Position::new(span.line_start as u32 - 1, span.column_start as u32 - 1),
+        lsp_types::Position::new(span.line_end as u32 - 1, span.column_end as u32 - 1),
     );
 
     lsp_types::Location { uri, range }
diff --git a/crates/rust-analyzer/src/document.rs b/crates/rust-analyzer/src/document.rs
index 04c7ee150..cf091510f 100644
--- a/crates/rust-analyzer/src/document.rs
+++ b/crates/rust-analyzer/src/document.rs
@@ -6,11 +6,11 @@
 /// client notifications.
 #[derive(Debug, Clone)]
 pub(crate) struct DocumentData {
-    pub(crate) version: Option<i64>,
+    pub(crate) version: i32,
 }
 
 impl DocumentData {
-    pub(crate) fn new(version: i64) -> Self {
-        DocumentData { version: Some(version) }
+    pub(crate) fn new(version: i32) -> Self {
+        DocumentData { version }
     }
 }
diff --git a/crates/rust-analyzer/src/global_state.rs b/crates/rust-analyzer/src/global_state.rs
index 63c70a09d..defe11c55 100644
--- a/crates/rust-analyzer/src/global_state.rs
+++ b/crates/rust-analyzer/src/global_state.rs
@@ -263,9 +263,9 @@ impl GlobalStateSnapshot {
         self.vfs.read().1[&id]
     }
 
-    pub(crate) fn url_file_version(&self, url: &Url) -> Option<i64> {
+    pub(crate) fn url_file_version(&self, url: &Url) -> Option<i32> {
         let path = from_proto::vfs_path(&url).ok()?;
-        self.mem_docs.get(&path)?.version
+        Some(self.mem_docs.get(&path)?.version)
     }
 
     pub(crate) fn anchored_path(&self, file_id: FileId, path: &str) -> Url {
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index a1057cc54..8d2d86f0e 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -573,7 +573,8 @@ pub(crate) fn handle_completion(
         .flat_map(|item| to_proto::completion_item(&line_index, line_endings, item))
         .collect();
 
-    Ok(Some(items.into()))
+    let completion_list = lsp_types::CompletionList { is_incomplete: false, items };
+    Ok(Some(completion_list.into()))
 }
 
 pub(crate) fn handle_folding_range(
diff --git a/crates/rust-analyzer/src/lsp_ext.rs b/crates/rust-analyzer/src/lsp_ext.rs
index a5c65fa3e..93ac45415 100644
--- a/crates/rust-analyzer/src/lsp_ext.rs
+++ b/crates/rust-analyzer/src/lsp_ext.rs
@@ -302,7 +302,7 @@ pub enum SnippetDocumentChangeOperation {
 #[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct SnippetTextDocumentEdit {
-    pub text_document: lsp_types::VersionedTextDocumentIdentifier,
+    pub text_document: lsp_types::OptionalVersionedTextDocumentIdentifier,
     pub edits: Vec<SnippetTextEdit>,
 }
 
diff --git a/crates/rust-analyzer/src/lsp_utils.rs b/crates/rust-analyzer/src/lsp_utils.rs
index 1d271a9d8..6427c7367 100644
--- a/crates/rust-analyzer/src/lsp_utils.rs
+++ b/crates/rust-analyzer/src/lsp_utils.rs
@@ -51,7 +51,7 @@ impl GlobalState {
         }
         let percentage = fraction.map(|f| {
             assert!(0.0 <= f && f <= 1.0);
-            f * 100.0
+            (f * 100.0) as u32
         });
         let token = lsp_types::ProgressToken::String(format!("rustAnalyzer/{}", title));
         let work_done_progress = match state {
@@ -98,11 +98,11 @@ pub(crate) fn apply_document_changes(
     // The VFS will normalize the end of lines to `\n`.
     enum IndexValid {
         All,
-        UpToLineExclusive(u64),
+        UpToLineExclusive(u32),
     }
 
     impl IndexValid {
-        fn covers(&self, line: u64) -> bool {
+        fn covers(&self, line: u32) -> bool {
             match *self {
                 IndexValid::UpToLineExclusive(to) => to > line,
                 _ => true,
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 68a53bbcb..6ea08adce 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -368,7 +368,7 @@ impl GlobalState {
                 let url = file_id_to_url(&self.vfs.read().0, file_id);
                 let diagnostics = self.diagnostics.diagnostics_for(file_id).cloned().collect();
                 let version = from_proto::vfs_path(&url)
-                    .map(|path| self.mem_docs.get(&path)?.version)
+                    .map(|path| self.mem_docs.get(&path).map(|it| it.version))
                     .unwrap_or_default();
 
                 self.send_notification::<lsp_types::notification::PublishDiagnostics>(
@@ -521,7 +521,7 @@ impl GlobalState {
                 let mut version = None;
                 if let Ok(path) = from_proto::vfs_path(&params.text_document.uri) {
                     match this.mem_docs.remove(&path) {
-                        Some(doc) => version = doc.version,
+                        Some(doc) => version = Some(doc.version),
                         None => log::error!("orphan DidCloseTextDocument: {}", path),
                     }
 
diff --git a/crates/rust-analyzer/src/reload.rs b/crates/rust-analyzer/src/reload.rs
index fa6e09f42..001bf5949 100644
--- a/crates/rust-analyzer/src/reload.rs
+++ b/crates/rust-analyzer/src/reload.rs
@@ -203,7 +203,11 @@ impl GlobalState {
                     let contents = loader.handle.load_sync(path);
                     vfs.set_file_contents(vfs_path.clone(), contents);
                 }
-                vfs.file_id(&vfs_path)
+                let res = vfs.file_id(&vfs_path);
+                if res.is_none() {
+                    log::error!("failed to load {}", path.display())
+                }
+                res
             };
             for ws in workspaces.iter() {
                 crate_graph.extend(ws.to_crate_graph(
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 4bdf4bf0f..2f35425bb 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -21,9 +21,7 @@ use crate::{
 
 pub(crate) fn position(line_index: &LineIndex, offset: TextSize) -> lsp_types::Position {
     let line_col = line_index.line_col(offset);
-    let line = u64::from(line_col.line);
-    let character = u64::from(line_col.col_utf16);
-    lsp_types::Position::new(line, character)
+    lsp_types::Position::new(line_col.line, line_col.col_utf16)
 }
 
 pub(crate) fn range(line_index: &LineIndex, range: TextRange) -> lsp_types::Range {
@@ -278,9 +276,9 @@ pub(crate) fn signature_help(
                     label.push_str(", ");
                 }
                 first = false;
-                let start = label.len() as u64;
+                let start = label.len() as u32;
                 label.push_str(param);
-                let end = label.len() as u64;
+                let end = label.len() as u32;
                 params.push(lsp_types::ParameterInformation {
                     label: lsp_types::ParameterLabel::LabelOffsets([start, end]),
                     documentation: None,
@@ -302,7 +300,7 @@ pub(crate) fn signature_help(
         })
     };
 
-    let active_parameter = call_info.active_parameter.map(|it| it as i64);
+    let active_parameter = call_info.active_parameter.map(|it| it as u32);
 
     let signature = lsp_types::SignatureInformation {
         label,
@@ -518,13 +516,13 @@ pub(crate) fn url_from_abs_path(path: &Path) -> lsp_types::Url {
     lsp_types::Url::parse(&url).unwrap()
 }
 
-pub(crate) fn versioned_text_document_identifier(
+pub(crate) fn optional_versioned_text_document_identifier(
     snap: &GlobalStateSnapshot,
     file_id: FileId,
-) -> lsp_types::VersionedTextDocumentIdentifier {
+) -> lsp_types::OptionalVersionedTextDocumentIdentifier {
     let url = url(snap, file_id);
     let version = snap.url_file_version(&url);
-    lsp_types::VersionedTextDocumentIdentifier { uri: url, version }
+    lsp_types::OptionalVersionedTextDocumentIdentifier { uri: url, version }
 }
 
 pub(crate) fn location(
@@ -613,7 +611,7 @@ pub(crate) fn snippet_text_document_edit(
     is_snippet: bool,
     source_file_edit: SourceFileEdit,
 ) -> Result<lsp_ext::SnippetTextDocumentEdit> {
-    let text_document = versioned_text_document_identifier(snap, source_file_edit.file_id);
+    let text_document = optional_versioned_text_document_identifier(snap, source_file_edit.file_id);
     let line_index = snap.analysis.file_line_index(source_file_edit.file_id)?;
     let line_endings = snap.file_line_endings(source_file_edit.file_id);
     let edits = source_file_edit
diff --git a/crates/rust-analyzer/tests/rust-analyzer/support.rs b/crates/rust-analyzer/tests/rust-analyzer/support.rs
index b210b98f0..456125789 100644
--- a/crates/rust-analyzer/tests/rust-analyzer/support.rs
+++ b/crates/rust-analyzer/tests/rust-analyzer/support.rs
@@ -108,7 +108,7 @@ pub(crate) fn project(fixture: &str) -> Server {
 }
 
 pub(crate) struct Server {
-    req_id: Cell<u64>,
+    req_id: Cell<i32>,
     messages: RefCell<Vec<Message>>,
     _thread: jod_thread::JoinHandle<()>,
     client: Connection,
@@ -165,7 +165,7 @@ impl Server {
         R::Params: Serialize,
     {
         let id = self.req_id.get();
-        self.req_id.set(id + 1);
+        self.req_id.set(id.wrapping_add(1));
 
         let r = Request::new(id.into(), R::METHOD.to_string(), params);
         self.send_request_(r)