10 files changed, 238 insertions, 35 deletions

diff --git a/crates/ra_hir_def/src/adt.rs b/crates/ra_hir_def/src/adt.rs
index 985f409e8..2bdfc2b8d 100644
--- a/crates/ra_hir_def/src/adt.rs
+++ b/crates/ra_hir_def/src/adt.rs
@@ -174,6 +174,7 @@ impl HasChildSource for VariantId {
     }
 }
 
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum StructKind {
     Tuple,
     Record,
diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
index b1626fa11..b3fb6d452 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -15,6 +15,7 @@ use ra_syntax::{
 use test_utils::tested_by;
 
 use crate::{
+    adt::StructKind,
     body::{Body, BodySourceMap, Expander, PatPtr},
     builtin_type::{BuiltinFloat, BuiltinInt},
     db::DefDatabase,
@@ -22,11 +23,12 @@ use crate::{
         ArithOp, Array, BinaryOp, BindingAnnotation, CmpOp, Expr, ExprId, Literal, LogicOp,
         MatchArm, Ordering, Pat, PatId, RecordFieldPat, RecordLitField, Statement,
     },
+    item_scope::BuiltinShadowMode,
     path::GenericArgs,
     path::Path,
     type_ref::{Mutability, TypeRef},
-    ConstLoc, ContainerId, DefWithBodyId, EnumLoc, FunctionLoc, Intern, ModuleDefId, StaticLoc,
-    StructLoc, TraitLoc, TypeAliasLoc, UnionLoc,
+    AdtId, ConstLoc, ContainerId, DefWithBodyId, EnumLoc, FunctionLoc, Intern, ModuleDefId,
+    StaticLoc, StructLoc, TraitLoc, TypeAliasLoc, UnionLoc,
 };
 
 pub(super) fn lower(
@@ -571,7 +573,37 @@ where
                 let name = bp.name().map(|nr| nr.as_name()).unwrap_or_else(Name::missing);
                 let annotation = BindingAnnotation::new(bp.is_mutable(), bp.is_ref());
                 let subpat = bp.pat().map(|subpat| self.collect_pat(subpat));
-                Pat::Bind { name, mode: annotation, subpat }
+                if annotation == BindingAnnotation::Unannotated && subpat.is_none() {
+                    // This could also be a single-segment path pattern. To
+                    // decide that, we need to try resolving the name.
+                    let (resolved, _) = self.expander.crate_def_map.resolve_path(
+                        self.db,
+                        self.expander.module.local_id,
+                        &name.clone().into(),
+                        BuiltinShadowMode::Other,
+                    );
+                    match resolved.take_values() {
+                        Some(ModuleDefId::ConstId(_)) => Pat::Path(name.into()),
+                        Some(ModuleDefId::EnumVariantId(_)) => {
+                            // this is only really valid for unit variants, but
+                            // shadowing other enum variants with a pattern is
+                            // an error anyway
+                            Pat::Path(name.into())
+                        }
+                        Some(ModuleDefId::AdtId(AdtId::StructId(s)))
+                            if self.db.struct_data(s).variant_data.kind() != StructKind::Record =>
+                        {
+                            // Funnily enough, record structs *can* be shadowed
+                            // by pattern bindings (but unit or tuple structs
+                            // can't).
+                            Pat::Path(name.into())
+                        }
+                        // shadowing statics is an error as well, so we just ignore that case here
+                        _ => Pat::Bind { name, mode: annotation, subpat },
+                    }
+                } else {
+                    Pat::Bind { name, mode: annotation, subpat }
+                }
             }
             ast::Pat::TupleStructPat(p) => {
                 let path = p.path().and_then(|path| self.expander.parse_path(path));
diff --git a/crates/ra_hir_def/src/expr.rs b/crates/ra_hir_def/src/expr.rs
index 9707c5527..66d004717 100644
--- a/crates/ra_hir_def/src/expr.rs
+++ b/crates/ra_hir_def/src/expr.rs
@@ -48,7 +48,7 @@ pub enum Literal {
 
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub enum Expr {
-    /// This is produced if syntax tree does not have a required expression piece.
+    /// This is produced if the syntax tree does not have a required expression piece.
     Missing,
     Path(Path),
     If {
diff --git a/crates/ra_hir_ty/src/infer/pat.rs b/crates/ra_hir_ty/src/infer/pat.rs
index a495ecbfe..bf8ea192b 100644
--- a/crates/ra_hir_ty/src/infer/pat.rs
+++ b/crates/ra_hir_ty/src/infer/pat.rs
@@ -189,7 +189,9 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         };
         // use a new type variable if we got Ty::Unknown here
         let ty = self.insert_type_vars_shallow(ty);
-        self.unify(&ty, expected);
+        if !self.unify(&ty, expected) {
+            // FIXME record mismatch, we need to change the type of self.type_mismatches for that
+        }
         let ty = self.resolve_ty_as_possible(ty);
         self.write_pat_ty(pat, ty.clone());
         ty
diff --git a/crates/ra_hir_ty/src/tests/patterns.rs b/crates/ra_hir_ty/src/tests/patterns.rs
index e25d6dbc4..81d00c2af 100644
--- a/crates/ra_hir_ty/src/tests/patterns.rs
+++ b/crates/ra_hir_ty/src/tests/patterns.rs
@@ -1,4 +1,4 @@
-use super::infer;
+use super::{infer, infer_with_mismatches};
 use insta::assert_snapshot;
 use test_utils::covers;
 
@@ -236,3 +236,47 @@ fn test(a1: A<u32>, o: Option<u64>) {
     "###
     );
 }
+
+#[test]
+fn infer_const_pattern() {
+    assert_snapshot!(
+        infer_with_mismatches(r#"
+enum Option<T> { None }
+use Option::None;
+struct Foo;
+const Bar: usize = 1;
+
+fn test() {
+    let a: Option<u32> = None;
+    let b: Option<i64> = match a {
+        None => None,
+    };
+    let _: () = match () { Foo => Foo }; // Expected mismatch
+    let _: () = match () { Bar => Bar }; // Expected mismatch
+}
+"#, true),
+        @r###"
+    [74; 75) '1': usize
+    [88; 310) '{     ...atch }': ()
+    [98; 99) 'a': Option<u32>
+    [115; 119) 'None': Option<u32>
+    [129; 130) 'b': Option<i64>
+    [146; 183) 'match ...     }': Option<i64>
+    [152; 153) 'a': Option<u32>
+    [164; 168) 'None': Option<u32>
+    [172; 176) 'None': Option<i64>
+    [193; 194) '_': ()
+    [201; 224) 'match ... Foo }': Foo
+    [207; 209) '()': ()
+    [212; 215) 'Foo': Foo
+    [219; 222) 'Foo': Foo
+    [255; 256) '_': ()
+    [263; 286) 'match ... Bar }': usize
+    [269; 271) '()': ()
+    [274; 277) 'Bar': usize
+    [281; 284) 'Bar': usize
+    [201; 224): expected (), got Foo
+    [263; 286): expected (), got usize
+    "###
+    );
+}
diff --git a/crates/ra_ide/src/references/rename.rs b/crates/ra_ide/src/references/rename.rs
index c46b78cb6..bdb90020b 100644
--- a/crates/ra_ide/src/references/rename.rs
+++ b/crates/ra_ide/src/references/rename.rs
@@ -98,6 +98,17 @@ fn rename_mod(
     };
     source_file_edits.push(edit);
 
+    if let Some(RangeInfo { range: _, info: refs }) = find_all_refs(db, position, None) {
+        let ref_edits = refs.references.into_iter().map(|reference| {
+            source_edit_from_file_id_range(
+                reference.file_range.file_id,
+                reference.file_range.range,
+                new_name,
+            )
+        });
+        source_file_edits.extend(ref_edits);
+    }
+
     Some(SourceChange::from_edits("rename", source_file_edits, file_system_edits))
 }
 
@@ -383,6 +394,101 @@ mod tests {
                );
     }
 
+    #[test]
+    fn test_module_rename_in_path() {
+        test_rename(
+            r#"
+    mod <|>foo {
+        pub fn bar() {}
+    }
+
+    fn main() {
+        foo::bar();
+    }"#,
+            "baz",
+            r#"
+    mod baz {
+        pub fn bar() {}
+    }
+
+    fn main() {
+        baz::bar();
+    }"#,
+        );
+    }
+
+    #[test]
+    fn test_rename_mod_filename_and_path() {
+        let (analysis, position) = analysis_and_position(
+            "
+            //- /lib.rs
+            mod bar;
+            fn f() {
+                bar::foo::fun()
+            }
+
+            //- /bar.rs
+            pub mod foo<|>;
+
+            //- /bar/foo.rs
+            // pub fn fun() {}
+            ",
+        );
+        let new_name = "foo2";
+        let source_change = analysis.rename(position, new_name).unwrap();
+        assert_debug_snapshot!(&source_change,
+@r###"
+        Some(
+            RangeInfo {
+                range: [8; 11),
+                info: SourceChange {
+                    label: "rename",
+                    source_file_edits: [
+                        SourceFileEdit {
+                            file_id: FileId(
+                                2,
+                            ),
+                            edit: TextEdit {
+                                atoms: [
+                                    AtomTextEdit {
+                                        delete: [8; 11),
+                                        insert: "foo2",
+                                    },
+                                ],
+                            },
+                        },
+                        SourceFileEdit {
+                            file_id: FileId(
+                                1,
+                            ),
+                            edit: TextEdit {
+                                atoms: [
+                                    AtomTextEdit {
+                                        delete: [27; 30),
+                                        insert: "foo2",
+                                    },
+                                ],
+                            },
+                        },
+                    ],
+                    file_system_edits: [
+                        MoveFile {
+                            src: FileId(
+                                3,
+                            ),
+                            dst_source_root: SourceRootId(
+                                0,
+                            ),
+                            dst_path: "bar/foo2.rs",
+                        },
+                    ],
+                    cursor_position: None,
+                },
+            },
+        )
+        "###);
+    }
+
     fn test_rename(text: &str, new_name: &str, expected: &str) {
         let (analysis, position) = single_file_with_position(text);
         let source_change = analysis.rename(position, new_name).unwrap();
diff --git a/crates/ra_mbe/src/subtree_source.rs b/crates/ra_mbe/src/subtree_source.rs
index dacca8279..91e324db9 100644
--- a/crates/ra_mbe/src/subtree_source.rs
+++ b/crates/ra_mbe/src/subtree_source.rs
@@ -1,7 +1,7 @@
 //! FIXME: write short doc here
 
 use ra_parser::{Token, TokenSource};
-use ra_syntax::{lex_single_valid_syntax_kind, SmolStr, SyntaxKind, SyntaxKind::*, T};
+use ra_syntax::{lex_single_syntax_kind, SmolStr, SyntaxKind, SyntaxKind::*, T};
 use std::cell::{Cell, Ref, RefCell};
 use tt::buffer::{Cursor, TokenBuffer};
 
@@ -129,7 +129,8 @@ fn convert_delim(d: Option<tt::DelimiterKind>, closing: bool) -> TtToken {
 }
 
 fn convert_literal(l: &tt::Literal) -> TtToken {
-    let kind = lex_single_valid_syntax_kind(&l.text)
+    let kind = lex_single_syntax_kind(&l.text)
+        .map(|(kind, _error)| kind)
         .filter(|kind| kind.is_literal())
         .unwrap_or_else(|| match l.text.as_ref() {
             "true" => T![true],
diff --git a/crates/ra_mbe/src/tests.rs b/crates/ra_mbe/src/tests.rs
index e0d689704..cb228702f 100644
--- a/crates/ra_mbe/src/tests.rs
+++ b/crates/ra_mbe/src/tests.rs
@@ -1374,14 +1374,22 @@ pub(crate) struct MacroFixture {
 
 impl MacroFixture {
     pub(crate) fn expand_tt(&self, invocation: &str) -> tt::Subtree {
-        let source_file = ast::SourceFile::parse(invocation).ok().unwrap();
+        self.try_expand_tt(invocation).unwrap()
+    }
+
+    fn try_expand_tt(&self, invocation: &str) -> Result<tt::Subtree, ExpandError> {
+        let source_file = ast::SourceFile::parse(invocation).tree();
         let macro_invocation =
             source_file.syntax().descendants().find_map(ast::MacroCall::cast).unwrap();
 
         let (invocation_tt, _) =
             ast_to_token_tree(&macro_invocation.token_tree().unwrap()).unwrap();
 
-        self.rules.expand(&invocation_tt).unwrap()
+        self.rules.expand(&invocation_tt)
+    }
+
+    fn assert_expand_err(&self, invocation: &str, err: &ExpandError) {
+        assert_eq!(self.try_expand_tt(invocation).as_ref(), Err(err));
     }
 
     fn expand_items(&self, invocation: &str) -> SyntaxNode {
@@ -1539,3 +1547,13 @@ fn test_repeat_bad_var() {
     )
     .assert_expand_items("foo!(b0 b1);", "b0 b1");
 }
+
+#[test]
+fn test_expand_bad_literal() {
+    parse_macro(
+        r#"
+        macro_rules! foo { ($i:literal) => {}; }
+    "#,
+    )
+    .assert_expand_err(r#"foo!(&k");"#, &ExpandError::NoMatchingRule);
+}
diff --git a/docs/user/features.md b/docs/user/features.md
index a00fa35da..f705e5115 100644
--- a/docs/user/features.md
+++ b/docs/user/features.md
@@ -1,10 +1,10 @@
-This documents is an index of features that rust-analyzer language server
+This document is an index of features that the rust-analyzer language server
 provides. Shortcuts are for the default VS Code layout. If there's no shortcut,
 you can use <kbd>Ctrl+Shift+P</kbd> to search for the corresponding action.
 
 ### Workspace Symbol <kbd>ctrl+t</kbd>
 
-Uses fuzzy-search to find types, modules and function by name across your
+Uses fuzzy-search to find types, modules and functions by name across your
 project and dependencies. This is **the** most useful feature, which improves code
 navigation tremendously. It mostly works on top of the built-in LSP
 functionality, however `#` and `*` symbols can be used to narrow down the
@@ -13,7 +13,7 @@ search. Specifically,
 - `Foo` searches for `Foo` type in the current workspace
 - `foo#` searches for `foo` function in the current workspace
 - `Foo*` searches for `Foo` type among dependencies, including `stdlib`
-- `foo#*` searches for `foo` function among dependencies.
+- `foo#*` searches for `foo` function among dependencies
 
 That is, `#` switches from "types" to all symbols, `*` switches from the current
 workspace to dependencies.
@@ -30,7 +30,7 @@ Provides a tree of the symbols defined in the file. Can be used to
 
 Some features trigger on typing certain characters:
 
-- typing `let =` tries to smartly add `;` if `=` is followed by an existing expression.
+- typing `let =` tries to smartly add `;` if `=` is followed by an existing expression
 - Enter inside comments automatically inserts `///`
 - typing `.` in a chain method call auto-indents
 
@@ -58,7 +58,7 @@ Navigates to the type of an identifier.
 
 #### Run
 
-Shows popup suggesting to run a test/benchmark/binary **at the current cursor
+Shows a popup suggesting to run a test/benchmark/binary **at the current cursor
 location**. Super useful for repeatedly running just a single test. Do bind this
 to a shortcut!
 
@@ -87,15 +87,15 @@ Shows the full macro expansion of the macro at current cursor.
 
 #### Status
 
-Shows internal statistic about memory usage of rust-analyzer
+Shows internal statistic about memory usage of rust-analyzer.
 
 #### Show RA Version
 
-Show current rust-analyzer version
+Show current rust-analyzer version.
 
-#### Run garbage collection
+#### Run Garbage Collection
 
-Manually triggers GC
+Manually triggers GC.
 
 #### Start Cargo Watch
 
@@ -103,7 +103,7 @@ Start `cargo watch` for live error highlighting. Will prompt to install if it's
 
 #### Stop Cargo Watch
 
-Stop `cargo watch`
+Stop `cargo watch`.
 
 ### Assists (Code Actions)
 
@@ -122,11 +122,11 @@ is placed at the appropriate position. Even though `if` is easy to type, you
 still want to complete it, to get ` { }` for free! `return` is inserted with a
 space or `;` depending on the return type of the function.
 
-When completing a function call, `()` are automatically inserted. If function
-takes arguments, cursor is positioned inside the parenthesis.
+When completing a function call, `()` are automatically inserted. If a function
+takes arguments, the cursor is positioned inside the parenthesis.
 
 There are postifx completions, which can be triggerd by typing something like
-`foo().if`. The word after `.` determines postifx completion, possible variants are:
+`foo().if`. The word after `.` determines postifx completion. Possible variants are:
 
 - `expr.if` -> `if expr {}`
 - `expr.match` -> `match expr {}`
@@ -147,12 +147,12 @@ There also snippet completions:
 
 - `tfn` -> `#[test] fn f(){}`
 
-### Code highlighting
+### Code Highlighting
 
 Experimental feature to let rust-analyzer highlight Rust code instead of using the
 default highlighter.
 
-#### Rainbow highlighting
+#### Rainbow Highlighting
 
 Experimental feature that, given code highlighting using rust-analyzer is
 active, will pick unique colors for identifiers.
diff --git a/docs/user/readme.adoc b/docs/user/readme.adoc
index 74fda0abe..f1386a8f9 100644
--- a/docs/user/readme.adoc
+++ b/docs/user/readme.adoc
@@ -6,10 +6,10 @@
 
 // Master copy of this document lives in the https://github.com/rust-analyzer/rust-analyzer repository
 
-At it's core, rust-analyzer is a *library* for semantic analysis of the Rust code as it changes over time.
+At its core, rust-analyzer is a *library* for semantic analysis of Rust code as it changes over time.
 This manual focuses on a specific usage of the library -- the implementation of
 https://microsoft.github.io/language-server-protocol/[Language Server Protocol].
-LSP allows various code editors, like VS Code, Emacs or Vim, to implement semantic feature like completion or goto definition by talking to an external language server process.
+LSP allows various code editors, like VS Code, Emacs or Vim, to implement semantic features like completion or goto definition by talking to an external language server process.
 
 To improve this document, send a pull request against
 https://github.com/rust-analyzer/rust-analyzer/blob/master/docs/user/readme.adoc[this file].
@@ -36,10 +36,9 @@ https://github.com/rust-analyzer/rust-analyzer/tree/master/editors/code[in tree]
 
 You can install the latest release of the plugin from
 https://marketplace.visualstudio.com/items?itemName=matklad.rust-analyzer[the marketplace].
-By default, the plugin will download the matching version of the server as well.
+By default, the plugin will prompt you to download the matching version of the server as well:
 
-// FIXME: update the image (its text has changed)
-image::https://user-images.githubusercontent.com/36276403/74103174-a40df100-4b52-11ea-81f4-372c70797924.png[]
+image::https://user-images.githubusercontent.com/9021944/75067008-17502500-54ba-11ea-835a-f92aac50e866.png[]
 
 The server binary is stored in `~/.config/Code/User/globalStorage/matklad.rust-analyzer`.
 
@@ -60,7 +59,7 @@ $ cargo xtask install
 ----
 
 You'll need Cargo, nodejs and npm for this.
-To make VS Code use the freshly build server, add this to the settings:
+To make VS Code use the freshly built server, add this to the settings:
 
 [source,json]
 ----
@@ -72,7 +71,7 @@ Note that installing via `xtask install` does not work for VS Code Remote, inste
 === Language Server Binary
 
 Other editors generally require `rust-analyzer` binary to be in `$PATH`.
-You can download pre-build binary from
+You can download the pre-built binary from
 https://github.com/rust-analyzer/rust-analyzer/releases[releases]
 page, or you can install it from source using the following command:
 
@@ -85,7 +84,7 @@ $ cargo xtask install --server
 
 Emacs support is maintained https://github.com/emacs-lsp/lsp-mode/blob/master/lsp-rust.el[upstream].
 
-1. Install recent version of `emacs-lsp` package by following the instructions https://github.com/emacs-lsp/lsp-mode[here].
+1. Install the most recent version of `emacs-lsp` package by following the instructions https://github.com/emacs-lsp/lsp-mode[here].
 2. Set `lsp-rust-server` to `'rust-analyzer`.
 3. Run `lsp` in a Rust buffer.
 4. (Optionally) bind commands like `lsp-rust-analyzer-join-lines`, `lsp-extend-selection` and `lsp-rust-analyzer-expand-macro` to keys.
@@ -112,7 +111,7 @@ The are several LSP client implementations for vim:
    https://github.com/autozimu/LanguageClient-neovim[here]
    * The github project wiki has extra tips on configuration
 
-2. Configure by adding this to your vim/neovim config file (replacing the existing rust specific line if it exists):
+2. Configure by adding this to your vim/neovim config file (replacing the existing Rust-specific line if it exists):
 +
 [source,vim]
 ----
@@ -123,7 +122,7 @@ let g:LanguageClient_serverCommands = {
 
 ==== nvim-lsp
 
-NeoVim 0.5 (not yet released) has built in language server support.
+NeoVim 0.5 (not yet released) has built-in language server support.
 For a quick start configuration of rust-analyzer, use https://github.com/neovim/nvim-lsp#rust_analyzer[neovim/nvim-lsp].
 Once `neovim/nvim-lsp` is installed, use `lua require'nvim_lsp'.rust_analyzer.setup({})` in your `init.vim`.