10 files changed, 259 insertions, 23 deletions

diff --git a/Cargo.lock b/Cargo.lock
index a5a43cffc..e9383a89a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -904,6 +904,7 @@ dependencies = [
  "ra_syntax 0.1.0",
  "ra_text_edit 0.1.0",
  "rustc-hash 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc_lexer 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "test_utils 0.1.0",
 ]
 
diff --git a/crates/ra_assists/Cargo.toml b/crates/ra_assists/Cargo.toml
index 02966bbda..d3b6aeb36 100644
--- a/crates/ra_assists/Cargo.toml
+++ b/crates/ra_assists/Cargo.toml
@@ -11,6 +11,7 @@ join_to_string = "0.1.3"
 itertools = "0.8.0"
 arrayvec = "0.4.10"
 rustc-hash = "1.0.1"
+rustc_lexer = "0.1.0"
 
 ra_syntax = { path = "../ra_syntax" }
 ra_text_edit = { path = "../ra_text_edit" }
diff --git a/crates/ra_assists/src/assists/raw_string.rs b/crates/ra_assists/src/assists/raw_string.rs
index 388ee7e97..2d2e31e51 100644
--- a/crates/ra_assists/src/assists/raw_string.rs
+++ b/crates/ra_assists/src/assists/raw_string.rs
@@ -2,6 +2,7 @@
 
 use hir::db::HirDatabase;
 use ra_syntax::{ast::AstNode, ast::Literal, TextRange, TextUnit};
+use rustc_lexer;
 
 use crate::{Assist, AssistCtx, AssistId};
 
@@ -10,13 +11,51 @@ pub(crate) fn make_raw_string(mut ctx: AssistCtx<impl HirDatabase>) -> Option<As
     if literal.token().kind() != ra_syntax::SyntaxKind::STRING {
         return None;
     }
+    let token = literal.token();
+    let text = token.text().as_str();
+    let usual_string_range = find_usual_string_range(text)?;
+    let start_of_inside = usual_string_range.start().to_usize() + 1;
+    let end_of_inside = usual_string_range.end().to_usize();
+    let inside_str = &text[start_of_inside..end_of_inside];
+    let mut unescaped = String::with_capacity(inside_str.len());
+    let mut error = Ok(());
+    rustc_lexer::unescape::unescape_str(
+        inside_str,
+        &mut |_, unescaped_char| match unescaped_char {
+            Ok(c) => unescaped.push(c),
+            Err(_) => error = Err(()),
+        },
+    );
+    if error.is_err() {
+        return None;
+    }
     ctx.add_action(AssistId("make_raw_string"), "make raw string", |edit| {
         edit.target(literal.syntax().text_range());
-        edit.insert(literal.syntax().text_range().start(), "r");
+        let max_hash_streak = count_hashes(&unescaped);
+        let mut hashes = String::with_capacity(max_hash_streak + 1);
+        for _ in 0..hashes.capacity() {
+            hashes.push('#');
+        }
+        edit.replace(
+            literal.syntax().text_range(),
+            format!("r{}\"{}\"{}", hashes, unescaped, hashes),
+        );
     });
     ctx.build()
 }
 
+fn count_hashes(s: &str) -> usize {
+    let mut max_hash_streak = 0usize;
+    for idx in s.match_indices("\"#").map(|(i, _)| i) {
+        let (_, sub) = s.split_at(idx + 1);
+        let nb_hash = sub.chars().take_while(|c| *c == '#').count();
+        if nb_hash > max_hash_streak {
+            max_hash_streak = nb_hash;
+        }
+    }
+    max_hash_streak
+}
+
 fn find_usual_string_range(s: &str) -> Option<TextRange> {
     Some(TextRange::from_to(
         TextUnit::from(s.find('"')? as u32),
@@ -94,10 +133,10 @@ mod test {
             make_raw_string,
             r#"
             fn f() {
-                let s = <|>"random string";
+                let s = <|>"random\nstring";
             }
             "#,
-            r#""random string""#,
+            r#""random\nstring""#,
         );
     }
 
@@ -107,44 +146,69 @@ mod test {
             make_raw_string,
             r#"
             fn f() {
-                let s = <|>"random string";
+                let s = <|>"random\nstring";
             }
             "#,
-            r#"
+            r##"
             fn f() {
-                let s = <|>r"random string";
+                let s = <|>r#"random
+string"#;
             }
-            "#,
+            "##,
         )
     }
 
     #[test]
-    fn make_raw_string_with_escaped_works() {
+    fn make_raw_string_hashes_inside_works() {
         check_assist(
             make_raw_string,
-            r#"
+            r###"
             fn f() {
-                let s = <|>"random\nstring";
+                let s = <|>"#random##\nstring";
             }
-            "#,
-            r#"
+            "###,
+            r####"
             fn f() {
-                let s = <|>r"random\nstring";
+                let s = <|>r#"#random##
+string"#;
             }
-            "#,
+            "####,
         )
     }
 
     #[test]
-    fn make_raw_string_not_works() {
-        check_assist_not_applicable(
+    fn make_raw_string_closing_hashes_inside_works() {
+        check_assist(
+            make_raw_string,
+            r###"
+            fn f() {
+                let s = <|>"#random\"##\nstring";
+            }
+            "###,
+            r####"
+            fn f() {
+                let s = <|>r###"#random"##
+string"###;
+            }
+            "####,
+        )
+    }
+
+    #[test]
+    fn make_raw_string_nothing_to_unescape_works() {
+        check_assist(
             make_raw_string,
             r#"
             fn f() {
-                let s = <|>r"random string";
+                let s = <|>"random string";
             }
             "#,
-        );
+            r##"
+            fn f() {
+                let s = <|>r#"random string"#;
+            }
+            "##,
+        )
     }
 
     #[test]
@@ -369,4 +433,14 @@ mod test {
             "#,
         );
     }
+
+    #[test]
+    fn count_hashes_test() {
+        assert_eq!(0, count_hashes("abc"));
+        assert_eq!(0, count_hashes("###"));
+        assert_eq!(1, count_hashes("\"#abc"));
+        assert_eq!(0, count_hashes("#abc"));
+        assert_eq!(2, count_hashes("#ab\"##c"));
+        assert_eq!(4, count_hashes("#ab\"##\"####c"));
+    }
 }
diff --git a/crates/ra_parser/src/grammar/expressions.rs b/crates/ra_parser/src/grammar/expressions.rs
index 74b23e2f7..45f2e3de4 100644
--- a/crates/ra_parser/src/grammar/expressions.rs
+++ b/crates/ra_parser/src/grammar/expressions.rs
@@ -250,6 +250,7 @@ fn current_op(p: &Parser) -> (u8, SyntaxKind) {
         T![!] if p.at(T![!=])  => (5,  T![!=]),
         T![-] if p.at(T![-=])  => (1,  T![-=]),
         T![-]                  => (10, T![-]),
+        T![as]                 => (12, T![as]),
 
         _                      => NOT_AN_OP
     }
@@ -278,6 +279,14 @@ fn expr_bp(p: &mut Parser, r: Restrictions, bp: u8) -> (Option<CompletedMarker>,
         if op_bp < bp {
             break;
         }
+        // test as_precedence
+        // fn foo() {
+        //     let _ = &1 as *const i32;
+        // }
+        if p.at(T![as]) {
+            lhs = cast_expr(p, lhs);
+            continue;
+        }
         let m = lhs.precede(p);
         p.bump(op);
 
@@ -344,6 +353,7 @@ fn lhs(p: &mut Parser, r: Restrictions) -> Option<(CompletedMarker, BlockLike)>
             ));
         }
     };
+    // parse the interior of the unary expression
     expr_bp(p, r, 255);
     Some((m.complete(p, kind), BlockLike::NotBlock))
 }
@@ -378,7 +388,6 @@ fn postfix_expr(
                 }
             },
             T![?] => try_expr(p, lhs),
-            T![as] => cast_expr(p, lhs),
             _ => break,
         };
         allow_calls = true;
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0146_as_precedence.rs b/crates/ra_syntax/test_data/parser/inline/ok/0146_as_precedence.rs
new file mode 100644
index 000000000..a06dec1fa
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0146_as_precedence.rs
@@ -0,0 +1,3 @@
+fn foo() {
+    let _ = &1 as *const i32;
+}
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0146_as_precedence.txt b/crates/ra_syntax/test_data/parser/inline/ok/0146_as_precedence.txt
new file mode 100644
index 000000000..9e3767fb7
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0146_as_precedence.txt
@@ -0,0 +1,43 @@
+SOURCE_FILE@[0; 43)
+  FN_DEF@[0; 42)
+    FN_KW@[0; 2) "fn"
+    WHITESPACE@[2; 3) " "
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7) "("
+      R_PAREN@[7; 8) ")"
+    WHITESPACE@[8; 9) " "
+    BLOCK_EXPR@[9; 42)
+      BLOCK@[9; 42)
+        L_CURLY@[9; 10) "{"
+        WHITESPACE@[10; 15) "\n    "
+        LET_STMT@[15; 40)
+          LET_KW@[15; 18) "let"
+          WHITESPACE@[18; 19) " "
+          PLACEHOLDER_PAT@[19; 20)
+            UNDERSCORE@[19; 20) "_"
+          WHITESPACE@[20; 21) " "
+          EQ@[21; 22) "="
+          WHITESPACE@[22; 23) " "
+          CAST_EXPR@[23; 39)
+            REF_EXPR@[23; 25)
+              AMP@[23; 24) "&"
+              LITERAL@[24; 25)
+                INT_NUMBER@[24; 25) "1"
+            WHITESPACE@[25; 26) " "
+            AS_KW@[26; 28) "as"
+            WHITESPACE@[28; 29) " "
+            POINTER_TYPE@[29; 39)
+              STAR@[29; 30) "*"
+              CONST_KW@[30; 35) "const"
+              WHITESPACE@[35; 36) " "
+              PATH_TYPE@[36; 39)
+                PATH@[36; 39)
+                  PATH_SEGMENT@[36; 39)
+                    NAME_REF@[36; 39)
+                      IDENT@[36; 39) "i32"
+          SEMI@[39; 40) ";"
+        WHITESPACE@[40; 41) "\n"
+        R_CURLY@[41; 42) "}"
+  WHITESPACE@[42; 43) "\n"
diff --git a/crates/ra_syntax/test_data/parser/ok/0058_unary_expr_precedence.rs b/crates/ra_syntax/test_data/parser/ok/0058_unary_expr_precedence.rs
new file mode 100644
index 000000000..100fccc64
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/ok/0058_unary_expr_precedence.rs
@@ -0,0 +1,7 @@
+fn foo() {
+    1 + *&2 + 3;
+    *&1 as u64;
+    *x(1);
+    &x[1];
+    -1..2;
+}
diff --git a/crates/ra_syntax/test_data/parser/ok/0058_unary_expr_precedence.txt b/crates/ra_syntax/test_data/parser/ok/0058_unary_expr_precedence.txt
new file mode 100644
index 000000000..d30cb63ff
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/ok/0058_unary_expr_precedence.txt
@@ -0,0 +1,97 @@
+SOURCE_FILE@[0; 79)
+  FN_DEF@[0; 78)
+    FN_KW@[0; 2) "fn"
+    WHITESPACE@[2; 3) " "
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7) "("
+      R_PAREN@[7; 8) ")"
+    WHITESPACE@[8; 9) " "
+    BLOCK_EXPR@[9; 78)
+      BLOCK@[9; 78)
+        L_CURLY@[9; 10) "{"
+        WHITESPACE@[10; 15) "\n    "
+        EXPR_STMT@[15; 27)
+          BIN_EXPR@[15; 26)
+            BIN_EXPR@[15; 22)
+              LITERAL@[15; 16)
+                INT_NUMBER@[15; 16) "1"
+              WHITESPACE@[16; 17) " "
+              PLUS@[17; 18) "+"
+              WHITESPACE@[18; 19) " "
+              PREFIX_EXPR@[19; 22)
+                STAR@[19; 20) "*"
+                REF_EXPR@[20; 22)
+                  AMP@[20; 21) "&"
+                  LITERAL@[21; 22)
+                    INT_NUMBER@[21; 22) "2"
+            WHITESPACE@[22; 23) " "
+            PLUS@[23; 24) "+"
+            WHITESPACE@[24; 25) " "
+            LITERAL@[25; 26)
+              INT_NUMBER@[25; 26) "3"
+          SEMI@[26; 27) ";"
+        WHITESPACE@[27; 32) "\n    "
+        EXPR_STMT@[32; 43)
+          CAST_EXPR@[32; 42)
+            PREFIX_EXPR@[32; 35)
+              STAR@[32; 33) "*"
+              REF_EXPR@[33; 35)
+                AMP@[33; 34) "&"
+                LITERAL@[34; 35)
+                  INT_NUMBER@[34; 35) "1"
+            WHITESPACE@[35; 36) " "
+            AS_KW@[36; 38) "as"
+            WHITESPACE@[38; 39) " "
+            PATH_TYPE@[39; 42)
+              PATH@[39; 42)
+                PATH_SEGMENT@[39; 42)
+                  NAME_REF@[39; 42)
+                    IDENT@[39; 42) "u64"
+          SEMI@[42; 43) ";"
+        WHITESPACE@[43; 48) "\n    "
+        EXPR_STMT@[48; 54)
+          PREFIX_EXPR@[48; 53)
+            STAR@[48; 49) "*"
+            CALL_EXPR@[49; 53)
+              PATH_EXPR@[49; 50)
+                PATH@[49; 50)
+                  PATH_SEGMENT@[49; 50)
+                    NAME_REF@[49; 50)
+                      IDENT@[49; 50) "x"
+              ARG_LIST@[50; 53)
+                L_PAREN@[50; 51) "("
+                LITERAL@[51; 52)
+                  INT_NUMBER@[51; 52) "1"
+                R_PAREN@[52; 53) ")"
+          SEMI@[53; 54) ";"
+        WHITESPACE@[54; 59) "\n    "
+        EXPR_STMT@[59; 65)
+          REF_EXPR@[59; 64)
+            AMP@[59; 60) "&"
+            INDEX_EXPR@[60; 64)
+              PATH_EXPR@[60; 61)
+                PATH@[60; 61)
+                  PATH_SEGMENT@[60; 61)
+                    NAME_REF@[60; 61)
+                      IDENT@[60; 61) "x"
+              L_BRACK@[61; 62) "["
+              LITERAL@[62; 63)
+                INT_NUMBER@[62; 63) "1"
+              R_BRACK@[63; 64) "]"
+          SEMI@[64; 65) ";"
+        WHITESPACE@[65; 70) "\n    "
+        EXPR_STMT@[70; 76)
+          RANGE_EXPR@[70; 75)
+            PREFIX_EXPR@[70; 72)
+              MINUS@[70; 71) "-"
+              LITERAL@[71; 72)
+                INT_NUMBER@[71; 72) "1"
+            DOTDOT@[72; 74) ".."
+            LITERAL@[74; 75)
+              INT_NUMBER@[74; 75) "2"
+          SEMI@[75; 76) ";"
+        WHITESPACE@[76; 77) "\n"
+        R_CURLY@[77; 78) "}"
+  WHITESPACE@[78; 79) "\n"
diff --git a/docs/user/README.md b/docs/user/README.md
index 44d6ee739..036b51d58 100644
--- a/docs/user/README.md
+++ b/docs/user/README.md
@@ -45,7 +45,7 @@ should adapt these manual installation instructions:
 ```
 $ git clone https://github.com/rust-analyzer/rust-analyzer.git --depth 1
 $ cd rust-analyzer
-$ cargo install --path ./crates/ra_lsp_server/ --force
+$ cargo install --path ./crates/ra_lsp_server/ --force --locked
 $ cd ./editors/code
 $ npm install
 $ ./node_modules/vsce/out/vsce package
diff --git a/docs/user/features.md b/docs/user/features.md
index 757a02838..8b7a8d7fc 100644
--- a/docs/user/features.md
+++ b/docs/user/features.md
@@ -459,17 +459,18 @@ fn foo<T: u32, F: FnOnce(T) -> T>() {}
 fn foo<T, F>() where T: u32, F: FnOnce(T) -> T {}
 ```
 
-- Make raw string
+- Make raw string unescaped
 
 ```rust
 // before:
 fn f() {
-    let s = <|>"abcd";
+    let s = <|>"ab\ncd";
 }
 
 // after:
 fn f() {
-    let s = <|>r"abcd";
+    let s = <|>r#"ab
+cd"#;
 }
 ```