16 files changed, 553 insertions, 218 deletions

diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index c7c7377d7..302a52491 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -39,7 +39,7 @@ pub use crate::{
         Struct, Trait, Type, TypeAlias, TypeParam, Union, VariantDef,
     },
     has_source::HasSource,
-    semantics::{original_range, PathResolution, Semantics, SemanticsScope},
+    semantics::{PathResolution, Semantics, SemanticsScope},
 };
 
 pub use hir_def::{
diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index c61a430e1..4315ad48b 100644
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs
@@ -13,10 +13,7 @@ use hir_expand::{hygiene::Hygiene, name::AsName, ExpansionInfo};
 use hir_ty::associated_type_shorthand_candidates;
 use itertools::Itertools;
 use rustc_hash::{FxHashMap, FxHashSet};
-use syntax::{
-    algo::{find_node_at_offset, skip_trivia_token},
-    ast, AstNode, Direction, SyntaxNode, SyntaxToken, TextRange, TextSize,
-};
+use syntax::{algo::find_node_at_offset, ast, AstNode, SyntaxNode, SyntaxToken, TextSize};
 
 use crate::{
     code_model::Access,
@@ -25,7 +22,7 @@ use crate::{
     semantics::source_to_def::{ChildContainer, SourceToDefCache, SourceToDefCtx},
     source_analyzer::{resolve_hir_path, SourceAnalyzer},
     AssocItem, Callable, Crate, Field, Function, HirFileId, ImplDef, InFile, Local, MacroDef,
-    Module, ModuleDef, Name, Origin, Path, ScopeDef, Trait, Type, TypeAlias, TypeParam, VariantDef,
+    Module, ModuleDef, Name, Path, ScopeDef, Trait, Type, TypeAlias, TypeParam, VariantDef,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -372,7 +369,7 @@ impl<'db> SemanticsImpl<'db> {
 
     fn original_range(&self, node: &SyntaxNode) -> FileRange {
         let node = self.find_file(node.clone());
-        original_range(self.db, node.as_ref())
+        node.as_ref().original_file_range(self.db.upcast())
     }
 
     fn diagnostics_display_range(&self, diagnostics: &dyn Diagnostic) -> FileRange {
@@ -380,7 +377,7 @@ impl<'db> SemanticsImpl<'db> {
         let root = self.db.parse_or_expand(src.file_id).unwrap();
         let node = src.value.to_node(&root);
         self.cache(root, src.file_id);
-        original_range(self.db, src.with_value(&node))
+        src.with_value(&node).original_file_range(self.db.upcast())
     }
 
     fn ancestors_with_macros(&self, node: SyntaxNode) -> impl Iterator<Item = SyntaxNode> + '_ {
@@ -771,68 +768,3 @@ impl<'a> SemanticsScope<'a> {
         resolve_hir_path(self.db, &self.resolver, &path)
     }
 }
-
-// FIXME: Change `HasSource` trait to work with `Semantics` and remove this?
-pub fn original_range(db: &dyn HirDatabase, node: InFile<&SyntaxNode>) -> FileRange {
-    if let Some(range) = original_range_opt(db, node) {
-        let original_file = range.file_id.original_file(db.upcast());
-        if range.file_id == original_file.into() {
-            return FileRange { file_id: original_file, range: range.value };
-        }
-
-        log::error!("Fail to mapping up more for {:?}", range);
-        return FileRange { file_id: range.file_id.original_file(db.upcast()), range: range.value };
-    }
-
-    // Fall back to whole macro call
-    if let Some(expansion) = node.file_id.expansion_info(db.upcast()) {
-        if let Some(call_node) = expansion.call_node() {
-            return FileRange {
-                file_id: call_node.file_id.original_file(db.upcast()),
-                range: call_node.value.text_range(),
-            };
-        }
-    }
-
-    FileRange { file_id: node.file_id.original_file(db.upcast()), range: node.value.text_range() }
-}
-
-fn original_range_opt(
-    db: &dyn HirDatabase,
-    node: InFile<&SyntaxNode>,
-) -> Option<InFile<TextRange>> {
-    let expansion = node.file_id.expansion_info(db.upcast())?;
-
-    // the input node has only one token ?
-    let single = skip_trivia_token(node.value.first_token()?, Direction::Next)?
-        == skip_trivia_token(node.value.last_token()?, Direction::Prev)?;
-
-    Some(node.value.descendants().find_map(|it| {
-        let first = skip_trivia_token(it.first_token()?, Direction::Next)?;
-        let first = ascend_call_token(db, &expansion, node.with_value(first))?;
-
-        let last = skip_trivia_token(it.last_token()?, Direction::Prev)?;
-        let last = ascend_call_token(db, &expansion, node.with_value(last))?;
-
-        if (!single && first == last) || (first.file_id != last.file_id) {
-            return None;
-        }
-
-        Some(first.with_value(first.value.text_range().cover(last.value.text_range())))
-    })?)
-}
-
-fn ascend_call_token(
-    db: &dyn HirDatabase,
-    expansion: &ExpansionInfo,
-    token: InFile<SyntaxToken>,
-) -> Option<InFile<SyntaxToken>> {
-    let (mapped, origin) = expansion.map_token_up(token.as_ref())?;
-    if origin != Origin::Call {
-        return None;
-    }
-    if let Some(info) = mapped.file_id.expansion_info(db.upcast()) {
-        return ascend_call_token(db, &info, mapped);
-    }
-    Some(mapped)
-}
diff --git a/crates/hir_def/src/body.rs b/crates/hir_def/src/body.rs
index 92bcc1705..c5d6f5fb0 100644
--- a/crates/hir_def/src/body.rs
+++ b/crates/hir_def/src/body.rs
@@ -103,8 +103,7 @@ impl Expander {
         local_scope: Option<&ItemScope>,
         macro_call: ast::MacroCall,
     ) -> ExpandResult<Option<(Mark, T)>> {
-        self.recursion_limit += 1;
-        if self.recursion_limit > EXPANSION_RECURSION_LIMIT {
+        if self.recursion_limit + 1 > EXPANSION_RECURSION_LIMIT {
             mark::hit!(your_stack_belongs_to_me);
             return ExpandResult::str_err("reached recursion limit during macro expansion".into());
         }
@@ -165,6 +164,7 @@ impl Expander {
 
         log::debug!("macro expansion {:#?}", node.syntax());
 
+        self.recursion_limit += 1;
         let mark = Mark {
             file_id: self.current_file_id,
             ast_id_map: mem::take(&mut self.ast_id_map),
diff --git a/crates/hir_def/src/body/tests.rs b/crates/hir_def/src/body/tests.rs
index 6dba9817d..de77d5fc9 100644
--- a/crates/hir_def/src/body/tests.rs
+++ b/crates/hir_def/src/body/tests.rs
@@ -134,3 +134,31 @@ fn f() {
       "#,
     );
 }
+
+#[test]
+fn dollar_crate_in_builtin_macro() {
+    check_diagnostics(
+        r#"
+#[macro_export]
+#[rustc_builtin_macro]
+macro_rules! format_args {}
+
+#[macro_export]
+macro_rules! arg {
+    () => {}
+}
+
+#[macro_export]
+macro_rules! outer {
+    () => {
+        $crate::format_args!( "", $crate::arg!(1) )
+    };
+}
+
+fn f() {
+    outer!();
+  //^^^^^^^^ leftover tokens
+}
+        "#,
+    )
+}
diff --git a/crates/hir_def/src/test_db.rs b/crates/hir_def/src/test_db.rs
index 00fe711fe..f8b150850 100644
--- a/crates/hir_def/src/test_db.rs
+++ b/crates/hir_def/src/test_db.rs
@@ -157,11 +157,12 @@ impl TestDB {
         db.diagnostics(|d| {
             let src = d.display_source();
             let root = db.parse_or_expand(src.file_id).unwrap();
-            // FIXME: macros...
-            let file_id = src.file_id.original_file(db);
-            let range = src.value.to_node(&root).text_range();
+
+            let node = src.map(|ptr| ptr.to_node(&root));
+            let frange = node.as_ref().original_file_range(db);
+
             let message = d.message().to_owned();
-            actual.entry(file_id).or_default().push((range, message));
+            actual.entry(frange.file_id).or_default().push((frange.range, message));
         });
 
         for (file_id, diags) in actual.iter_mut() {
diff --git a/crates/hir_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs
index 44a5556b6..79b970850 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -287,23 +287,34 @@ fn concat_expand(
     _arg_id: EagerMacroId,
     tt: &tt::Subtree,
 ) -> ExpandResult<Option<(tt::Subtree, FragmentKind)>> {
+    let mut err = None;
     let mut text = String::new();
     for (i, t) in tt.token_trees.iter().enumerate() {
         match t {
             tt::TokenTree::Leaf(tt::Leaf::Literal(it)) if i % 2 == 0 => {
-                text += &match unquote_str(&it) {
-                    Some(s) => s,
-                    None => {
-                        return ExpandResult::only_err(mbe::ExpandError::ConversionError);
-                    }
-                };
+                // concat works with string and char literals, so remove any quotes.
+                // It also works with integer, float and boolean literals, so just use the rest
+                // as-is.
+
+                text += it
+                    .text
+                    .trim_start_matches(|c| match c {
+                        'r' | '#' | '\'' | '"' => true,
+                        _ => false,
+                    })
+                    .trim_end_matches(|c| match c {
+                        '#' | '\'' | '"' => true,
+                        _ => false,
+                    });
             }
             tt::TokenTree::Leaf(tt::Leaf::Punct(punct)) if i % 2 == 1 && punct.char == ',' => (),
-            _ => return ExpandResult::only_err(mbe::ExpandError::UnexpectedToken),
+            _ => {
+                err.get_or_insert(mbe::ExpandError::UnexpectedToken);
+            }
         }
     }
 
-    ExpandResult::ok(Some((quote!(#text), FragmentKind::Expr)))
+    ExpandResult { value: Some((quote!(#text), FragmentKind::Expr)), err }
 }
 
 fn relative_file(
@@ -686,4 +697,19 @@ mod tests {
 
         assert_eq!(expanded, r#"b"""#);
     }
+
+    #[test]
+    fn test_concat_expand() {
+        let expanded = expand_builtin_macro(
+            r##"
+            #[rustc_builtin_macro]
+            macro_rules! concat {}
+            concat!("foo", 0, r#"bar"#);
+            "##,
+        );
+
+        assert_eq!(expanded, r#""foo0bar""#);
+
+        // FIXME: `true`/`false` literals don't work.
+    }
 }
diff --git a/crates/hir_expand/src/lib.rs b/crates/hir_expand/src/lib.rs
index 2633fd8f7..1a9428514 100644
--- a/crates/hir_expand/src/lib.rs
+++ b/crates/hir_expand/src/lib.rs
@@ -20,11 +20,11 @@ pub use mbe::{ExpandError, ExpandResult};
 use std::hash::Hash;
 use std::sync::Arc;
 
-use base_db::{impl_intern_key, salsa, CrateId, FileId};
+use base_db::{impl_intern_key, salsa, CrateId, FileId, FileRange};
 use syntax::{
-    algo,
+    algo::{self, skip_trivia_token},
     ast::{self, AstNode},
-    SyntaxNode, SyntaxToken, TextSize,
+    Direction, SyntaxNode, SyntaxToken, TextRange, TextSize,
 };
 
 use crate::ast_id_map::FileAstId;
@@ -445,6 +445,70 @@ impl InFile<SyntaxNode> {
     }
 }
 
+impl<'a> InFile<&'a SyntaxNode> {
+    pub fn original_file_range(self, db: &dyn db::AstDatabase) -> FileRange {
+        if let Some(range) = original_range_opt(db, self) {
+            let original_file = range.file_id.original_file(db);
+            if range.file_id == original_file.into() {
+                return FileRange { file_id: original_file, range: range.value };
+            }
+
+            log::error!("Fail to mapping up more for {:?}", range);
+            return FileRange { file_id: range.file_id.original_file(db), range: range.value };
+        }
+
+        // Fall back to whole macro call.
+        let mut node = self.cloned();
+        while let Some(call_node) = node.file_id.call_node(db) {
+            node = call_node;
+        }
+
+        let orig_file = node.file_id.original_file(db);
+        assert_eq!(node.file_id, orig_file.into());
+        FileRange { file_id: orig_file, range: node.value.text_range() }
+    }
+}
+
+fn original_range_opt(
+    db: &dyn db::AstDatabase,
+    node: InFile<&SyntaxNode>,
+) -> Option<InFile<TextRange>> {
+    let expansion = node.file_id.expansion_info(db)?;
+
+    // the input node has only one token ?
+    let single = skip_trivia_token(node.value.first_token()?, Direction::Next)?
+        == skip_trivia_token(node.value.last_token()?, Direction::Prev)?;
+
+    Some(node.value.descendants().find_map(|it| {
+        let first = skip_trivia_token(it.first_token()?, Direction::Next)?;
+        let first = ascend_call_token(db, &expansion, node.with_value(first))?;
+
+        let last = skip_trivia_token(it.last_token()?, Direction::Prev)?;
+        let last = ascend_call_token(db, &expansion, node.with_value(last))?;
+
+        if (!single && first == last) || (first.file_id != last.file_id) {
+            return None;
+        }
+
+        Some(first.with_value(first.value.text_range().cover(last.value.text_range())))
+    })?)
+}
+
+fn ascend_call_token(
+    db: &dyn db::AstDatabase,
+    expansion: &ExpansionInfo,
+    token: InFile<SyntaxToken>,
+) -> Option<InFile<SyntaxToken>> {
+    let (mapped, origin) = expansion.map_token_up(token.as_ref())?;
+    if origin != Origin::Call {
+        return None;
+    }
+    if let Some(info) = mapped.file_id.expansion_info(db) {
+        return ascend_call_token(db, &info, mapped);
+    }
+    Some(mapped)
+}
+
 impl InFile<SyntaxToken> {
     pub fn ancestors_with_macros(
         self,
diff --git a/crates/ide/src/diagnostics/fixes.rs b/crates/ide/src/diagnostics/fixes.rs
index d275dd75b..24d08651e 100644
--- a/crates/ide/src/diagnostics/fixes.rs
+++ b/crates/ide/src/diagnostics/fixes.rs
@@ -68,7 +68,8 @@ impl DiagnosticWithFix for MissingFields {
         }
 
         let root = sema.db.parse_or_expand(self.file)?;
-        let old_field_list = self.field_list_parent.to_node(&root).record_expr_field_list()?;
+        let field_list_parent = self.field_list_parent.to_node(&root);
+        let old_field_list = field_list_parent.record_expr_field_list()?;
         let mut new_field_list = old_field_list.clone();
         for f in self.missed_fields.iter() {
             let field =
@@ -85,7 +86,7 @@ impl DiagnosticWithFix for MissingFields {
         Some(Fix::new(
             "Fill struct fields",
             SourceFileEdit { file_id: self.file.original_file(sema.db), edit }.into(),
-            sema.original_range(&old_field_list.syntax()).range,
+            sema.original_range(&field_list_parent.syntax()).range,
         ))
     }
 }
diff --git a/crates/ide/src/display/navigation_target.rs b/crates/ide/src/display/navigation_target.rs
index 0c429a262..4790d648a 100644
--- a/crates/ide/src/display/navigation_target.rs
+++ b/crates/ide/src/display/navigation_target.rs
@@ -1,7 +1,7 @@
 //! FIXME: write short doc here
 
 use either::Either;
-use hir::{original_range, AssocItem, FieldSource, HasSource, InFile, ModuleSource};
+use hir::{AssocItem, FieldSource, HasSource, InFile, ModuleSource};
 use ide_db::base_db::{FileId, SourceDatabase};
 use ide_db::{defs::Definition, RootDatabase};
 use syntax::{
@@ -62,7 +62,8 @@ impl NavigationTarget {
     pub(crate) fn from_module_to_decl(db: &RootDatabase, module: hir::Module) -> NavigationTarget {
         let name = module.name(db).map(|it| it.to_string().into()).unwrap_or_default();
         if let Some(src) = module.declaration_source(db) {
-            let frange = original_range(db, src.as_ref().map(|it| it.syntax()));
+            let node = src.as_ref().map(|it| it.syntax());
+            let frange = node.original_file_range(db);
             let mut res = NavigationTarget::from_syntax(
                 frange.file_id,
                 name,
@@ -104,8 +105,8 @@ impl NavigationTarget {
         let name =
             node.value.name().map(|it| it.text().clone()).unwrap_or_else(|| SmolStr::new("_"));
         let focus_range =
-            node.value.name().map(|it| original_range(db, node.with_value(it.syntax())).range);
-        let frange = original_range(db, node.map(|it| it.syntax()));
+            node.value.name().map(|it| node.with_value(it.syntax()).original_file_range(db).range);
+        let frange = node.map(|it| it.syntax()).original_file_range(db);
 
         NavigationTarget::from_syntax(
             frange.file_id,
@@ -124,7 +125,7 @@ impl NavigationTarget {
     ) -> NavigationTarget {
         let name =
             named.value.name().map(|it| it.text().clone()).unwrap_or_else(|| SmolStr::new("_"));
-        let frange = original_range(db, node.map(|it| it.syntax()));
+        let frange = node.map(|it| it.syntax()).original_file_range(db);
 
         NavigationTarget::from_syntax(
             frange.file_id,
@@ -236,7 +237,7 @@ impl ToNav for hir::Module {
                 (node.syntax(), node.name().map(|it| it.syntax().text_range()))
             }
         };
-        let frange = original_range(db, src.with_value(syntax));
+        let frange = src.with_value(syntax).original_file_range(db);
         NavigationTarget::from_syntax(frange.file_id, name, focus, frange.range, syntax.kind())
     }
 }
@@ -246,14 +247,14 @@ impl ToNav for hir::ImplDef {
         let src = self.source(db);
         let derive_attr = self.is_builtin_derive(db);
         let frange = if let Some(item) = &derive_attr {
-            original_range(db, item.syntax())
+            item.syntax().original_file_range(db)
         } else {
-            original_range(db, src.as_ref().map(|it| it.syntax()))
+            src.as_ref().map(|it| it.syntax()).original_file_range(db)
         };
         let focus_range = if derive_attr.is_some() {
             None
         } else {
-            src.value.self_ty().map(|ty| original_range(db, src.with_value(ty.syntax())).range)
+            src.value.self_ty().map(|ty| src.with_value(ty.syntax()).original_file_range(db).range)
         };
 
         NavigationTarget::from_syntax(
@@ -278,7 +279,7 @@ impl ToNav for hir::Field {
                 res
             }
             FieldSource::Pos(it) => {
-                let frange = original_range(db, src.with_value(it.syntax()));
+                let frange = src.with_value(it.syntax()).original_file_range(db);
                 NavigationTarget::from_syntax(
                     frange.file_id,
                     "".into(),
@@ -331,7 +332,7 @@ impl ToNav for hir::Local {
             }
             Either::Right(it) => it.syntax().clone(),
         };
-        let full_range = original_range(db, src.with_value(&node));
+        let full_range = src.with_value(&node).original_file_range(db);
         let name = match self.name(db) {
             Some(it) => it.to_string().into(),
             None => "".into(),
diff --git a/crates/proc_macro_srv/src/lib.rs b/crates/proc_macro_srv/src/lib.rs
index 6e890f8e2..9cca96994 100644
--- a/crates/proc_macro_srv/src/lib.rs
+++ b/crates/proc_macro_srv/src/lib.rs
@@ -40,7 +40,8 @@ impl ProcMacroSrv {
         match expander.expand(&task.macro_name, &task.macro_body, task.attributes.as_ref()) {
             Ok(expansion) => Ok(ExpansionResult { expansion }),
             Err(msg) => {
-                Err(format!("Cannot perform expansion for {}: error {:?}", &task.macro_name, msg))
+                let msg = msg.as_str().unwrap_or("<unknown error>");
+                Err(format!("proc-macro panicked: {}", msg))
             }
         }
     }
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index 0a055b039..039976e4b 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -27,7 +27,7 @@ pico-args = "0.3.1"
 oorandom = "11.1.2"
 rustc-hash = "1.1.0"
 serde = { version = "1.0.106", features = ["derive"] }
-serde_json = "1.0.48"
+serde_json = { version = "1.0.48", features = ["preserve_order"] }
 threadpool = "1.7.1"
 rayon = "1.5"
 mimalloc = { version = "0.1.19", default-features = false, optional = true }
diff --git a/crates/rust-analyzer/src/bin/args.rs b/crates/rust-analyzer/src/bin/args.rs
index 8ddf1e031..0a471154e 100644
--- a/crates/rust-analyzer/src/bin/args.rs
+++ b/crates/rust-analyzer/src/bin/args.rs
@@ -28,6 +28,7 @@ pub(crate) enum Command {
     StructuredSearch { debug_snippet: Option<String>, patterns: Vec<SsrPattern> },
     ProcMacro,
     RunServer,
+    PrintConfigSchema,
     Version,
     Help,
 }
@@ -135,6 +136,10 @@ impl Args {
             return Ok(Args { verbosity, log_file: None, command: Command::Help });
         }
 
+        if matches.contains("--print-config-schema") {
+            return Ok(Args { verbosity, log_file, command: Command::PrintConfigSchema });
+        }
+
         let subcommand = match matches.subcommand()? {
             Some(it) => it,
             None => {
diff --git a/crates/rust-analyzer/src/bin/main.rs b/crates/rust-analyzer/src/bin/main.rs
index 21fba8302..defdcbd74 100644
--- a/crates/rust-analyzer/src/bin/main.rs
+++ b/crates/rust-analyzer/src/bin/main.rs
@@ -31,6 +31,9 @@ fn try_main() -> Result<()> {
     setup_logging(args.log_file)?;
     match args.command {
         args::Command::RunServer => run_server()?,
+        args::Command::PrintConfigSchema => {
+            println!("{:#}", Config::json_schema());
+        }
         args::Command::ProcMacro => proc_macro_srv::cli::run()?,
 
         args::Command::Parse { no_dump } => cli::parse(no_dump)?,
diff --git a/crates/rust-analyzer/src/cli/analysis_stats.rs b/crates/rust-analyzer/src/cli/analysis_stats.rs
index 98ef0cd68..58d284d47 100644
--- a/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -8,7 +8,7 @@ use std::{
 
 use hir::{
     db::{AstDatabase, DefDatabase, HirDatabase},
-    original_range, AssocItem, Crate, HasSource, HirDisplay, ModuleDef,
+    AssocItem, Crate, HasSource, HirDisplay, ModuleDef,
 };
 use hir_def::FunctionId;
 use hir_ty::{Ty, TypeWalk};
@@ -232,7 +232,7 @@ impl AnalysisStatsCmd {
                             // But also, we should just turn the type mismatches into diagnostics and provide these
                             let root = db.parse_or_expand(src.file_id).unwrap();
                             let node = src.map(|e| e.to_node(&root).syntax().clone());
-                            let original_range = original_range(db, node.as_ref());
+                            let original_range = node.as_ref().original_file_range(db);
                             let path = vfs.file_path(original_range.file_id);
                             let line_index =
                                 host.analysis().file_line_index(original_range.file_id).unwrap();
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 5243b50c8..bd41a971b 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -13,14 +13,166 @@ use flycheck::FlycheckConfig;
 use hir::PrefixKind;
 use ide::{AssistConfig, CompletionConfig, DiagnosticsConfig, HoverConfig, InlayHintsConfig};
 use ide_db::helpers::insert_use::MergeBehaviour;
+use itertools::Itertools;
 use lsp_types::{ClientCapabilities, MarkupKind};
 use project_model::{CargoConfig, ProjectJson, ProjectJsonData, ProjectManifest};
 use rustc_hash::FxHashSet;
-use serde::Deserialize;
+use serde::{de::DeserializeOwned, Deserialize};
 use vfs::AbsPathBuf;
 
 use crate::{caps::enabled_completions_resolve_capabilities, diagnostics::DiagnosticsMapConfig};
 
+config_data! {
+    struct ConfigData {
+        /// The strategy to use when inserting new imports or merging imports.
+        assist_importMergeBehaviour: MergeBehaviourDef = "\"full\"",
+        /// The path structure for newly inserted paths to use.
+        assist_importPrefix: ImportPrefixDef           = "\"plain\"",
+
+        /// Show function name and docs in parameter hints.
+        callInfo_full: bool = "true",
+
+        /// Automatically refresh project info via `cargo metadata` on
+        /// Cargo.toml changes.
+        cargo_autoreload: bool           = "true",
+        /// Activate all available features.
+        cargo_allFeatures: bool          = "false",
+        /// List of features to activate.
+        cargo_features: Vec<String>      = "[]",
+        /// Run `cargo check` on startup to get the correct value for package
+        /// OUT_DIRs.
+        cargo_loadOutDirsFromCheck: bool = "false",
+        /// Do not activate the `default` feature.
+        cargo_noDefaultFeatures: bool    = "false",
+        /// Compilation target (target triple).
+        cargo_target: Option<String>     = "null",
+        /// Internal config for debugging, disables loading of sysroot crates.
+        cargo_noSysroot: bool            = "false",
+
+        /// Run specified `cargo check` command for diagnostics on save.
+        checkOnSave_enable: bool                         = "true",
+        /// Check with all features (will be passed as `--all-features`).
+        /// Defaults to `rust-analyzer.cargo.allFeatures`.
+        checkOnSave_allFeatures: Option<bool>            = "null",
+        /// Check all targets and tests (will be passed as `--all-targets`).
+        checkOnSave_allTargets: bool                     = "true",
+        /// Cargo command to use for `cargo check`.
+        checkOnSave_command: String                      = "\"check\"",
+        /// Do not activate the `default` feature.
+        checkOnSave_noDefaultFeatures: Option<bool>      = "null",
+        /// Check for a specific target. Defaults to
+        /// `rust-analyzer.cargo.target`.
+        checkOnSave_target: Option<String>               = "null",
+        /// Extra arguments for `cargo check`.
+        checkOnSave_extraArgs: Vec<String>               = "[]",
+        /// List of features to activate. Defaults to
+        /// `rust-analyzer.cargo.features`.
+        checkOnSave_features: Option<Vec<String>>        = "null",
+        /// Advanced option, fully override the command rust-analyzer uses for
+        /// checking. The command should include `--message-format=json` or
+        /// similar option.
+        checkOnSave_overrideCommand: Option<Vec<String>> = "null",
+
+        /// Whether to add argument snippets when completing functions.
+        completion_addCallArgumentSnippets: bool = "true",
+        /// Whether to add parenthesis when completing functions.
+        completion_addCallParenthesis: bool      = "true",
+        /// Whether to show postfix snippets like `dbg`, `if`, `not`, etc.
+        completion_postfix_enable: bool          = "true",
+        /// Toggles the additional completions that automatically add imports when completed.
+        /// Note that your client have to specify the `additionalTextEdits` LSP client capability to truly have this feature enabled.
+        completion_autoimport_enable: bool       = "true",
+
+        /// Whether to show native rust-analyzer diagnostics.
+        diagnostics_enable: bool                = "true",
+        /// Whether to show experimental rust-analyzer diagnostics that might
+        /// have more false positives than usual.
+        diagnostics_enableExperimental: bool    = "true",
+        /// List of rust-analyzer diagnostics to disable.
+        diagnostics_disabled: FxHashSet<String> = "[]",
+        /// List of warnings that should be displayed with info severity.\nThe
+        /// warnings will be indicated by a blue squiggly underline in code and
+        /// a blue icon in the problems panel.
+        diagnostics_warningsAsHint: Vec<String> = "[]",
+        /// List of warnings that should be displayed with hint severity.\nThe
+        /// warnings will be indicated by faded text or three dots in code and
+        /// will not show up in the problems panel.
+        diagnostics_warningsAsInfo: Vec<String> = "[]",
+
+        /// Controls file watching implementation.
+        files_watcher: String = "\"client\"",
+
+        /// Whether to show `Debug` action. Only applies when
+        /// `#rust-analyzer.hoverActions.enable#` is set.
+        hoverActions_debug: bool           = "true",
+        /// Whether to show HoverActions in Rust files.
+        hoverActions_enable: bool          = "true",
+        /// Whether to show `Go to Type Definition` action. Only applies when
+        /// `#rust-analyzer.hoverActions.enable#` is set.
+        hoverActions_gotoTypeDef: bool     = "true",
+        /// Whether to show `Implementations` action. Only applies when
+        /// `#rust-analyzer.hoverActions.enable#` is set.
+        hoverActions_implementations: bool = "true",
+        /// Whether to show `Run` action. Only applies when
+        /// `#rust-analyzer.hoverActions.enable#` is set.
+        hoverActions_run: bool             = "true",
+        /// Use markdown syntax for links in hover.
+        hoverActions_linksInHover: bool    = "true",
+
+        /// Whether to show inlay type hints for method chains.
+        inlayHints_chainingHints: bool      = "true",
+        /// Maximum length for inlay hints.
+        inlayHints_maxLength: Option<usize> = "null",
+        /// Whether to show function parameter name inlay hints at the call
+        /// site.
+        inlayHints_parameterHints: bool     = "true",
+        /// Whether to show inlay type hints for variables.
+        inlayHints_typeHints: bool          = "true",
+
+        /// Whether to show `Debug` lens. Only applies when
+        /// `#rust-analyzer.lens.enable#` is set.
+        lens_debug: bool            = "true",
+        /// Whether to show CodeLens in Rust files.
+        lens_enable: bool           = "true",
+        /// Whether to show `Implementations` lens. Only applies when
+        /// `#rust-analyzer.lens.enable#` is set.
+        lens_implementations: bool  = "true",
+        /// Whether to show `Run` lens. Only applies when
+        /// `#rust-analyzer.lens.enable#` is set.
+        lens_run: bool              = "true",
+        /// Whether to show `Method References` lens. Only applies when
+        /// `#rust-analyzer.lens.enable#` is set.
+        lens_methodReferences: bool = "false",
+
+        /// Disable project auto-discovery in favor of explicitly specified set
+        /// of projects.  \nElements must be paths pointing to Cargo.toml,
+        /// rust-project.json, or JSON objects in rust-project.json format.
+        linkedProjects: Vec<ManifestOrProjectJson> = "[]",
+        /// Number of syntax trees rust-analyzer keeps in memory.
+        lruCapacity: Option<usize>                 = "null",
+        /// Whether to show `can't find Cargo.toml` error message.
+        notifications_cargoTomlNotFound: bool      = "true",
+        /// Enable Proc macro support, cargo.loadOutDirsFromCheck must be
+        /// enabled.
+        procMacro_enable: bool                     = "false",
+
+        /// Command to be executed instead of 'cargo' for runnables.
+        runnables_overrideCargo: Option<String> = "null",
+        /// Additional arguments to be passed to cargo for runnables such as
+        /// tests or binaries.\nFor example, it may be '--release'.
+        runnables_cargoExtraArgs: Vec<String>   = "[]",
+
+        /// Path to the rust compiler sources, for usage in rustc_private projects.
+        rustcSource : Option<String> = "null",
+
+        /// Additional arguments to rustfmt.
+        rustfmt_extraArgs: Vec<String>               = "[]",
+        /// Advanced option, fully override the command rust-analyzer uses for
+        /// formatting.
+        rustfmt_overrideCommand: Option<Vec<String>> = "null",
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct Config {
     pub client_caps: ClientCapsConfig,
@@ -149,25 +301,27 @@ pub struct ClientCapsConfig {
 
 impl Config {
     pub fn new(root_path: AbsPathBuf) -> Self {
-        Config {
+        // Defaults here don't matter, we'll immediately re-write them with
+        // ConfigData.
+        let mut res = Config {
             client_caps: ClientCapsConfig::default(),
 
-            publish_diagnostics: true,
+            publish_diagnostics: false,
             diagnostics: DiagnosticsConfig::default(),
             diagnostics_map: DiagnosticsMapConfig::default(),
             lru_capacity: None,
             proc_macro_srv: None,
             files: FilesConfig { watcher: FilesWatcher::Notify, exclude: Vec::new() },
-            notifications: NotificationsConfig { cargo_toml_not_found: true },
+            notifications: NotificationsConfig { cargo_toml_not_found: false },
 
-            cargo_autoreload: true,
+            cargo_autoreload: false,
             cargo: CargoConfig::default(),
             rustfmt: RustfmtConfig::Rustfmt { extra_args: Vec::new() },
             flycheck: Some(FlycheckConfig::CargoCommand {
-                command: "check".to_string(),
+                command: String::new(),
                 target_triple: None,
                 no_default_features: false,
-                all_targets: true,
+                all_targets: false,
                 all_features: false,
                 extra_args: Vec::new(),
                 features: Vec::new(),
@@ -175,35 +329,32 @@ impl Config {
             runnables: RunnablesConfig::default(),
 
             inlay_hints: InlayHintsConfig {
-                type_hints: true,
-                parameter_hints: true,
-                chaining_hints: true,
+                type_hints: false,
+                parameter_hints: false,
+                chaining_hints: false,
                 max_length: None,
             },
-            completion: CompletionConfig {
-                enable_postfix_completions: true,
-                enable_autoimport_completions: true,
-                add_call_parenthesis: true,
-                add_call_argument_snippets: true,
-                ..CompletionConfig::default()
-            },
+            completion: CompletionConfig::default(),
             assist: AssistConfig::default(),
-            call_info_full: true,
+            call_info_full: false,
             lens: LensConfig::default(),
             hover: HoverConfig::default(),
             semantic_tokens_refresh: false,
             linked_projects: Vec::new(),
             root_path,
-        }
+        };
+        res.do_update(serde_json::json!({}));
+        res
     }
-
     pub fn update(&mut self, json: serde_json::Value) {
         log::info!("Config::update({:#})", json);
-
         if json.is_null() || json.as_object().map_or(false, |it| it.is_empty()) {
             return;
         }
-
+        self.do_update(json);
+        log::info!("Config::update() = {:#?}", self);
+    }
+    fn do_update(&mut self, json: serde_json::Value) {
         let data = ConfigData::from_json(json);
 
         self.publish_diagnostics = data.diagnostics_enable;
@@ -349,8 +500,6 @@ impl Config {
             links_in_hover: data.hoverActions_linksInHover,
             markdown: true,
         };
-
-        log::info!("Config::update() = {:#?}", self);
     }
 
     pub fn update_caps(&mut self, caps: &ClientCapabilities) {
@@ -434,6 +583,10 @@ impl Config {
             }
         }
     }
+
+    pub fn json_schema() -> serde_json::Value {
+        ConfigData::json_schema()
+    }
 }
 
 #[derive(Deserialize)]
@@ -459,94 +612,206 @@ enum ImportPrefixDef {
     ByCrate,
 }
 
-macro_rules! config_data {
-    (struct $name:ident { $($field:ident: $ty:ty = $default:expr,)*}) => {
+macro_rules! _config_data {
+    (struct $name:ident {
+        $(
+            $(#[doc=$doc:literal])*
+            $field:ident: $ty:ty = $default:expr,
+        )*
+    }) => {
         #[allow(non_snake_case)]
         struct $name { $($field: $ty,)* }
         impl $name {
             fn from_json(mut json: serde_json::Value) -> $name {
                 $name {$(
-                    $field: {
-                        let pointer = stringify!($field).replace('_', "/");
-                        let pointer = format!("/{}", pointer);
-                        json.pointer_mut(&pointer)
-                            .and_then(|it| serde_json::from_value(it.take()).ok())
-                            .unwrap_or($default)
-                    },
+                    $field: get_field(&mut json, stringify!($field), $default),
                 )*}
             }
-        }
 
+            fn json_schema() -> serde_json::Value {
+                schema(&[
+                    $({
+                        let field = stringify!($field);
+                        let ty = stringify!($ty);
+                        (field, ty, &[$($doc),*], $default)
+                    },)*
+                ])
+            }
+
+            #[cfg(test)]
+            fn manual() -> String {
+                manual(&[
+                    $({
+                        let field = stringify!($field);
+                        let ty = stringify!($ty);
+                        (field, ty, &[$($doc),*], $default)
+                    },)*
+                ])
+            }
+        }
     };
 }
+use _config_data as config_data;
+
+fn get_field<T: DeserializeOwned>(
+    json: &mut serde_json::Value,
+    field: &'static str,
+    default: &str,
+) -> T {
+    let default = serde_json::from_str(default).unwrap();
+
+    let mut pointer = field.replace('_', "/");
+    pointer.insert(0, '/');
+    json.pointer_mut(&pointer)
+        .and_then(|it| serde_json::from_value(it.take()).ok())
+        .unwrap_or(default)
+}
 
-config_data! {
-    struct ConfigData {
-        assist_importMergeBehaviour: MergeBehaviourDef = MergeBehaviourDef::Full,
-        assist_importPrefix: ImportPrefixDef           = ImportPrefixDef::Plain,
-
-        callInfo_full: bool = true,
-
-        cargo_autoreload: bool           = true,
-        cargo_allFeatures: bool          = false,
-        cargo_features: Vec<String>      = Vec::new(),
-        cargo_loadOutDirsFromCheck: bool = false,
-        cargo_noDefaultFeatures: bool    = false,
-        cargo_target: Option<String>     = None,
-        cargo_noSysroot: bool            = false,
-
-        checkOnSave_enable: bool                         = true,
-        checkOnSave_allFeatures: Option<bool>            = None,
-        checkOnSave_allTargets: bool                     = true,
-        checkOnSave_command: String                      = "check".into(),
-        checkOnSave_noDefaultFeatures: Option<bool>      = None,
-        checkOnSave_target: Option<String>               = None,
-        checkOnSave_extraArgs: Vec<String>               = Vec::new(),
-        checkOnSave_features: Option<Vec<String>>        = None,
-        checkOnSave_overrideCommand: Option<Vec<String>> = None,
-
-        completion_addCallArgumentSnippets: bool = true,
-        completion_addCallParenthesis: bool      = true,
-        completion_postfix_enable: bool          = true,
-        completion_autoimport_enable: bool       = true,
-
-        diagnostics_enable: bool                = true,
-        diagnostics_enableExperimental: bool    = true,
-        diagnostics_disabled: FxHashSet<String> = FxHashSet::default(),
-        diagnostics_warningsAsHint: Vec<String> = Vec::new(),
-        diagnostics_warningsAsInfo: Vec<String> = Vec::new(),
-
-        files_watcher: String = "client".into(),
-
-        hoverActions_debug: bool           = true,
-        hoverActions_enable: bool          = true,
-        hoverActions_gotoTypeDef: bool     = true,
-        hoverActions_implementations: bool = true,
-        hoverActions_run: bool             = true,
-        hoverActions_linksInHover: bool    = true,
-
-        inlayHints_chainingHints: bool      = true,
-        inlayHints_maxLength: Option<usize> = None,
-        inlayHints_parameterHints: bool     = true,
-        inlayHints_typeHints: bool          = true,
-
-        lens_debug: bool            = true,
-        lens_enable: bool           = true,
-        lens_implementations: bool  = true,
-        lens_run: bool              = true,
-        lens_methodReferences: bool = false,
-
-        linkedProjects: Vec<ManifestOrProjectJson> = Vec::new(),
-        lruCapacity: Option<usize>                 = None,
-        notifications_cargoTomlNotFound: bool      = true,
-        procMacro_enable: bool                     = false,
-
-        runnables_overrideCargo: Option<String> = None,
-        runnables_cargoExtraArgs: Vec<String>   = Vec::new(),
-
-        rustfmt_extraArgs: Vec<String>               = Vec::new(),
-        rustfmt_overrideCommand: Option<Vec<String>> = None,
-
-        rustcSource : Option<String> = None,
+fn schema(fields: &[(&'static str, &'static str, &[&str], &str)]) -> serde_json::Value {
+    for ((f1, ..), (f2, ..)) in fields.iter().zip(&fields[1..]) {
+        fn key(f: &str) -> &str {
+            f.splitn(2, "_").next().unwrap()
+        };
+        assert!(key(f1) <= key(f2), "wrong field order: {:?} {:?}", f1, f2);
+    }
+
+    let map = fields
+        .iter()
+        .map(|(field, ty, doc, default)| {
+            let name = field.replace("_", ".");
+            let name = format!("rust-analyzer.{}", name);
+            let props = field_props(field, ty, doc, default);
+            (name, props)
+        })
+        .collect::<serde_json::Map<_, _>>();
+    map.into()
+}
+
+fn field_props(field: &str, ty: &str, doc: &[&str], default: &str) -> serde_json::Value {
+    let doc = doc.iter().map(|it| it.trim()).join(" ");
+    assert!(
+        doc.ends_with('.') && doc.starts_with(char::is_uppercase),
+        "bad docs for {}: {:?}",
+        field,
+        doc
+    );
+    let default = default.parse::<serde_json::Value>().unwrap();
+
+    let mut map = serde_json::Map::default();
+    macro_rules! set {
+        ($($key:literal: $value:tt),*$(,)?) => {{$(
+            map.insert($key.into(), serde_json::json!($value));
+        )*}};
+    }
+    set!("markdownDescription": doc);
+    set!("default": default);
+
+    match ty {
+        "bool" => set!("type": "boolean"),
+        "String" => set!("type": "string"),
+        "Vec<String>" => set! {
+            "type": "array",
+            "items": { "type": "string" },
+        },
+        "FxHashSet<String>" => set! {
+            "type": "array",
+            "items": { "type": "string" },
+            "uniqueItems": true,
+        },
+        "Option<usize>" => set! {
+            "type": ["null", "integer"],
+            "minimum": 0,
+        },
+        "Option<String>" => set! {
+            "type": ["null", "string"],
+        },
+        "Option<bool>" => set! {
+            "type": ["null", "boolean"],
+        },
+        "Option<Vec<String>>" => set! {
+            "type": ["null", "array"],
+            "items": { "type": "string" },
+        },
+        "MergeBehaviourDef" => set! {
+            "type": "string",
+            "enum": ["none", "full", "last"],
+            "enumDescriptions": [
+                "No merging",
+                "Merge all layers of the import trees",
+                "Only merge the last layer of the import trees"
+            ],
+        },
+        "ImportPrefixDef" => set! {
+            "type": "string",
+            "enum": [
+                "plain",
+                "by_self",
+                "by_crate"
+            ],
+            "enumDescriptions": [
+                "Insert import paths relative to the current module, using up to one `super` prefix if the parent module contains the requested item.",
+                "Prefix all import paths with `self` if they don't begin with `self`, `super`, `crate` or a crate name",
+                "Force import paths to be absolute by always starting them with `crate` or the crate name they refer to."
+            ],
+        },
+        "Vec<ManifestOrProjectJson>" => set! {
+            "type": "array",
+            "items": { "type": ["string", "object"] },
+        },
+        _ => panic!("{}: {}", ty, default),
+    }
+
+    map.into()
+}
+
+#[cfg(test)]
+fn manual(fields: &[(&'static str, &'static str, &[&str], &str)]) -> String {
+    fields
+        .iter()
+        .map(|(field, _ty, doc, default)| {
+            let name = field.replace("_", ".");
+            let name = format!("rust-analyzer.{} (default: `{}`)", name, default);
+            format!("{}::\n{}\n", name, doc.join(" "))
+        })
+        .collect::<String>()
+}
+
+#[cfg(test)]
+mod tests {
+    use std::fs;
+
+    use test_utils::project_dir;
+
+    use super::*;
+
+    #[test]
+    fn schema_in_sync_with_package_json() {
+        let s = Config::json_schema();
+        let schema = format!("{:#}", s);
+        let schema = schema.trim_start_matches('{').trim_end_matches('}');
+
+        let package_json = project_dir().join("editors/code/package.json");
+        let package_json = fs::read_to_string(&package_json).unwrap();
+
+        let p = remove_ws(&package_json);
+        let s = remove_ws(&schema);
+
+        assert!(p.contains(&s), "update config in package.json. New config:\n{:#}", schema);
+    }
+
+    #[test]
+    fn schema_in_sync_with_docs() {
+        let docs_path = project_dir().join("docs/user/generated_config.adoc");
+        let current = fs::read_to_string(&docs_path).unwrap();
+        let expected = ConfigData::manual();
+
+        if remove_ws(&current) != remove_ws(&expected) {
+            fs::write(&docs_path, expected).unwrap();
+            panic!("updated config manual");
+        }
+    }
+
+    fn remove_ws(text: &str) -> String {
+        text.replace(char::is_whitespace, "")
     }
 }
diff --git a/crates/test_utils/src/lib.rs b/crates/test_utils/src/lib.rs
index a49be4602..05940a546 100644
--- a/crates/test_utils/src/lib.rs
+++ b/crates/test_utils/src/lib.rs
@@ -321,12 +321,11 @@ fn lines_match_works() {
 /// as paths). You can use a `"{...}"` string literal as a wildcard for
 /// arbitrary nested JSON. Arrays are sorted before comparison.
 pub fn find_mismatch<'a>(expected: &'a Value, actual: &'a Value) -> Option<(&'a Value, &'a Value)> {
-    use serde_json::Value::*;
     match (expected, actual) {
-        (&Number(ref l), &Number(ref r)) if l == r => None,
-        (&Bool(l), &Bool(r)) if l == r => None,
-        (&String(ref l), &String(ref r)) if lines_match(l, r) => None,
-        (&Array(ref l), &Array(ref r)) => {
+        (Value::Number(l), Value::Number(r)) if l == r => None,
+        (Value::Bool(l), Value::Bool(r)) if l == r => None,
+        (Value::String(l), Value::String(r)) if lines_match(l, r) => None,
+        (Value::Array(l), Value::Array(r)) => {
             if l.len() != r.len() {
                 return Some((expected, actual));
             }
@@ -350,17 +349,26 @@ pub fn find_mismatch<'a>(expected: &'a Value, actual: &'a Value) -> Option<(&'a
                 None
             }
         }
-        (&Object(ref l), &Object(ref r)) => {
+        (Value::Object(l), Value::Object(r)) => {
+            fn sorted_values(obj: &serde_json::Map<String, Value>) -> Vec<&Value> {
+                let mut entries = obj.iter().collect::<Vec<_>>();
+                entries.sort_by_key(|it| it.0);
+                entries.into_iter().map(|(_k, v)| v).collect::<Vec<_>>()
+            }
+
             let same_keys = l.len() == r.len() && l.keys().all(|k| r.contains_key(k));
             if !same_keys {
                 return Some((expected, actual));
             }
 
-            l.values().zip(r.values()).filter_map(|(l, r)| find_mismatch(l, r)).next()
+            let l = sorted_values(l);
+            let r = sorted_values(r);
+
+            l.into_iter().zip(r).filter_map(|(l, r)| find_mismatch(l, r)).next()
         }
-        (&Null, &Null) => None,
+        (Value::Null, Value::Null) => None,
         // magic string literal "{...}" acts as wildcard for any sub-JSON
-        (&String(ref l), _) if l == "{...}" => None,
+        (Value::String(l), _) if l == "{...}" => None,
         _ => Some((expected, actual)),
     }
 }