7 files changed, 245 insertions, 25 deletions

diff --git a/.travis.yml b/.travis.yml
index 8d10a43f0..ebff7d8b0 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -12,12 +12,15 @@ build: &rust_build
         - rustup component add rust-src
         - cargo test --no-run  # let's measure compile time separately
         - cargo test
+        - cargo doc --all --no-deps
     env:
         - RUSTFLAGS="-D warnings", CARGO_INCREMENTAL=0
 
 matrix:
     include:
         - os: linux
+          before_script:
+              - DEPLOY_DOCS=1
           <<: *rust_build
         - language: node_js
           node_js: node
@@ -43,3 +46,14 @@ branches:
         - staging
         - master
         - trying
+
+deploy:
+    provider: pages
+    skip-cleanup: true
+    github-token: $DOCS_TOKEN  # Set in the settings page of your repository, as a secure variable
+    keep-history: true
+    local-dir: target/doc
+    branch: gh-pages
+    on:
+        branch: master
+        condition: $DEPLOY_DOCS = 1
diff --git a/README.md b/README.md
index 3a0c9dee1..7c81413d9 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,7 @@
 # Rust Analyzer
 
 [![Build Status](https://travis-ci.org/rust-analyzer/rust-analyzer.svg?branch=master)](https://travis-ci.org/rust-analyzer/rust-analyzer)
+[![Master docs](https://img.shields.io/badge/docs-master-blue.svg)](https://rust-analyzer.github.io/rust-analyzer/ra_ide_api/index.html)
 
 Rust Analyzer is an **experimental** modular compiler frontend for the Rust
 language. It is a part of a larger rls-2.0 effort to create excellent IDE
diff --git a/crates/ra_assists/src/add_missing_impl_members.rs b/crates/ra_assists/src/add_missing_impl_members.rs
index 4435c4b5d..e13f54c4f 100644
--- a/crates/ra_assists/src/add_missing_impl_members.rs
+++ b/crates/ra_assists/src/add_missing_impl_members.rs
@@ -9,7 +9,35 @@ use ra_fmt::{leading_indent, reindent};
 
 use itertools::Itertools;
 
-pub(crate) fn add_missing_impl_members(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+enum AddMissingImplMembersMode {
+    DefaultMethodsOnly,
+    NoDefaultMethods,
+}
+
+pub(crate) fn add_missing_impl_members(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+    add_missing_impl_members_inner(
+        ctx,
+        AddMissingImplMembersMode::NoDefaultMethods,
+        "add_impl_missing_members",
+        "add missing impl members",
+    )
+}
+
+pub(crate) fn add_missing_default_members(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+    add_missing_impl_members_inner(
+        ctx,
+        AddMissingImplMembersMode::DefaultMethodsOnly,
+        "add_impl_default_members",
+        "add impl default members",
+    )
+}
+
+fn add_missing_impl_members_inner(
+    mut ctx: AssistCtx<impl HirDatabase>,
+    mode: AddMissingImplMembersMode,
+    assist_id: &'static str,
+    label: &'static str,
+) -> Option<Assist> {
     let impl_node = ctx.node_at_offset::<ast::ImplBlock>()?;
     let impl_item_list = impl_node.item_list()?;
 
@@ -35,6 +63,10 @@ pub(crate) fn add_missing_impl_members(mut ctx: AssistCtx<impl HirDatabase>) ->
         trait_fns
             .into_iter()
             .filter(|t| def_name(t).is_some())
+            .filter(|t| match mode {
+                AddMissingImplMembersMode::DefaultMethodsOnly => t.body().is_some(),
+                AddMissingImplMembersMode::NoDefaultMethods => t.body().is_none(),
+            })
             .filter(|t| impl_fns.iter().all(|i| def_name(i) != def_name(t)))
             .collect()
     };
@@ -42,7 +74,7 @@ pub(crate) fn add_missing_impl_members(mut ctx: AssistCtx<impl HirDatabase>) ->
         return None;
     }
 
-    ctx.add_action(AssistId("add_impl_missing_members"), "add missing impl members", |edit| {
+    ctx.add_action(AssistId(assist_id), label, |edit| {
         let (parent_indent, indent) = {
             // FIXME: Find a way to get the indent already used in the file.
             // Now, we copy the indent of first item or indent with 4 spaces relative to impl block
@@ -103,11 +135,13 @@ fn build_func_body(def: &ast::FnDef) -> String {
     let mut buf = String::new();
 
     for child in def.syntax().children() {
-        if child.kind() == SyntaxKind::SEMI {
-            buf.push_str(" { unimplemented!() }")
-        } else {
-            child.text().push_to(&mut buf);
-        }
+        match (child.prev_sibling().map(|c| c.kind()), child.kind()) {
+            (_, SyntaxKind::SEMI) => buf.push_str(" { unimplemented!() }"),
+            (_, SyntaxKind::ATTR) | (_, SyntaxKind::COMMENT) => {}
+            (Some(SyntaxKind::ATTR), SyntaxKind::WHITESPACE)
+            | (Some(SyntaxKind::COMMENT), SyntaxKind::WHITESPACE) => {}
+            _ => child.text().push_to(&mut buf),
+        };
     }
 
     buf.trim_end().to_string()
@@ -180,8 +214,7 @@ struct S;
 
 impl Foo for S {
     fn bar(&self) {}
-    fn foo(&self) { unimplemented!() }
-    fn baz(&self) -> u32 { 42 }<|>
+    fn foo(&self) { unimplemented!() }<|>
 }",
         );
     }
@@ -193,7 +226,7 @@ impl Foo for S {
             "
 trait Foo { fn foo(&self); }
 struct S;
-impl Foo for S {<|>}",
+impl Foo for S { <|> }",
             "
 trait Foo { fn foo(&self); }
 struct S;
@@ -232,8 +265,8 @@ impl Foo for S { <|> }",
     }
 
     #[test]
-    fn test_ignore_unnamed_trait_members() {
-        check_assist(
+    fn test_ignore_unnamed_trait_members_and_default_methods() {
+        check_assist_not_applicable(
             add_missing_impl_members,
             "
 trait Foo {
@@ -242,15 +275,6 @@ trait Foo {
 }
 struct S;
 impl Foo for S { <|> }",
-            "
-trait Foo {
-    fn (arg: u32);
-    fn valid(some: u32) -> bool { false }
-}
-struct S;
-impl Foo for S {
-    fn valid(some: u32) -> bool { false }<|>
-}",
         )
     }
 
@@ -260,7 +284,7 @@ impl Foo for S {
             add_missing_impl_members,
             "
 trait Foo {
-    fn valid(some: u32) -> bool { false }
+    fn valid(some: u32) -> bool;
 }
 struct S;
 
@@ -269,15 +293,66 @@ mod my_mod {
 }",
             "
 trait Foo {
-    fn valid(some: u32) -> bool { false }
+    fn valid(some: u32) -> bool;
 }
 struct S;
 
 mod my_mod {
     impl crate::Foo for S {
-        fn valid(some: u32) -> bool { false }<|>
+        fn valid(some: u32) -> bool { unimplemented!() }<|>
+    }
+}",
+        )
+    }
+
+    #[test]
+    fn test_with_docstring_and_attrs() {
+        check_assist(
+            add_missing_impl_members,
+            r#"
+#[doc(alias = "test alias")]
+trait Foo {
+    /// doc string
+    #[must_use]
+    fn foo(&self);
+}
+struct S;
+impl Foo for S {}<|>"#,
+            r#"
+#[doc(alias = "test alias")]
+trait Foo {
+    /// doc string
+    #[must_use]
+    fn foo(&self);
+}
+struct S;
+impl Foo for S {
+    fn foo(&self) { unimplemented!() }<|>
+}"#,
+        )
     }
+
+    #[test]
+    fn test_default_methods() {
+        check_assist(
+            add_missing_default_members,
+            "
+trait Foo {
+    fn valid(some: u32) -> bool { false }
+    fn foo(some: u32) -> bool;
+}
+struct S;
+impl Foo for S { <|> }",
+            "
+trait Foo {
+    fn valid(some: u32) -> bool { false }
+    fn foo(some: u32) -> bool;
+}
+struct S;
+impl Foo for S {
+    fn valid(some: u32) -> bool { false }<|>
 }",
         )
     }
+
 }
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index eb5248ae4..8900fbc4b 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -114,6 +114,7 @@ fn all_assists<DB: HirDatabase>() -> &'static [fn(AssistCtx<DB>) -> Option<Assis
         remove_dbg::remove_dbg,
         auto_import::auto_import,
         add_missing_impl_members::add_missing_impl_members,
+        add_missing_impl_members::add_missing_default_members,
     ]
 }
 
diff --git a/crates/ra_parser/src/grammar/types.rs b/crates/ra_parser/src/grammar/types.rs
index adc189a29..fdd4f2c52 100644
--- a/crates/ra_parser/src/grammar/types.rs
+++ b/crates/ra_parser/src/grammar/types.rs
@@ -202,12 +202,15 @@ pub(super) fn for_binder(p: &mut Parser) {
 
 // test for_type
 // type A = for<'a> fn() -> ();
+// fn foo<T>(_t: &T) where for<'a> &'a T: Iterator {}
+// fn bar<T>(_t: &T) where for<'a> &'a mut T: Iterator {}
 pub(super) fn for_type(p: &mut Parser) {
     assert!(p.at(FOR_KW));
     let m = p.start();
     for_binder(p);
     match p.current() {
         FN_KW | UNSAFE_KW | EXTERN_KW => fn_pointer_type(p),
+        AMP => reference_type(p),
         _ if paths::is_path_start(p) => path_type_(p, false),
         _ => p.error("expected a path"),
     }
diff --git a/crates/ra_syntax/tests/data/parser/inline/ok/0081_for_type.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0081_for_type.rs
index 4d6a18c6b..7cde5c532 100644
--- a/crates/ra_syntax/tests/data/parser/inline/ok/0081_for_type.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0081_for_type.rs
@@ -1 +1,3 @@
 type A = for<'a> fn() -> ();
+fn foo<T>(_t: &T) where for<'a> &'a T: Iterator {}
+fn bar<T>(_t: &T) where for<'a> &'a mut T: Iterator {}
diff --git a/crates/ra_syntax/tests/data/parser/inline/ok/0081_for_type.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0081_for_type.txt
index 6e7e6bda1..568f61fb2 100644
--- a/crates/ra_syntax/tests/data/parser/inline/ok/0081_for_type.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0081_for_type.txt
@@ -1,4 +1,4 @@
-SOURCE_FILE@[0; 29)
+SOURCE_FILE@[0; 135)
   TYPE_ALIAS_DEF@[0; 28)
     TYPE_KW@[0; 4)
     WHITESPACE@[4; 5)
@@ -29,3 +29,127 @@ SOURCE_FILE@[0; 29)
             R_PAREN@[26; 27)
     SEMI@[27; 28)
   WHITESPACE@[28; 29)
+  FN_DEF@[29; 79)
+    FN_KW@[29; 31)
+    WHITESPACE@[31; 32)
+    NAME@[32; 35)
+      IDENT@[32; 35) "foo"
+    TYPE_PARAM_LIST@[35; 38)
+      L_ANGLE@[35; 36)
+      TYPE_PARAM@[36; 37)
+        NAME@[36; 37)
+          IDENT@[36; 37) "T"
+      R_ANGLE@[37; 38)
+    PARAM_LIST@[38; 46)
+      L_PAREN@[38; 39)
+      PARAM@[39; 45)
+        BIND_PAT@[39; 41)
+          NAME@[39; 41)
+            IDENT@[39; 41) "_t"
+        COLON@[41; 42)
+        WHITESPACE@[42; 43)
+        REFERENCE_TYPE@[43; 45)
+          AMP@[43; 44)
+          PATH_TYPE@[44; 45)
+            PATH@[44; 45)
+              PATH_SEGMENT@[44; 45)
+                NAME_REF@[44; 45)
+                  IDENT@[44; 45) "T"
+      R_PAREN@[45; 46)
+    WHITESPACE@[46; 47)
+    WHERE_CLAUSE@[47; 76)
+      WHERE_KW@[47; 52)
+      WHITESPACE@[52; 53)
+      WHERE_PRED@[53; 76)
+        FOR_TYPE@[53; 66)
+          FOR_KW@[53; 56)
+          TYPE_PARAM_LIST@[56; 60)
+            L_ANGLE@[56; 57)
+            LIFETIME_PARAM@[57; 59)
+              LIFETIME@[57; 59) "'a"
+            R_ANGLE@[59; 60)
+          WHITESPACE@[60; 61)
+          REFERENCE_TYPE@[61; 66)
+            AMP@[61; 62)
+            LIFETIME@[62; 64) "'a"
+            WHITESPACE@[64; 65)
+            PATH_TYPE@[65; 66)
+              PATH@[65; 66)
+                PATH_SEGMENT@[65; 66)
+                  NAME_REF@[65; 66)
+                    IDENT@[65; 66) "T"
+        COLON@[66; 67)
+        WHITESPACE@[67; 68)
+        PATH_TYPE@[68; 76)
+          PATH@[68; 76)
+            PATH_SEGMENT@[68; 76)
+              NAME_REF@[68; 76)
+                IDENT@[68; 76) "Iterator"
+    WHITESPACE@[76; 77)
+    BLOCK@[77; 79)
+      L_CURLY@[77; 78)
+      R_CURLY@[78; 79)
+  WHITESPACE@[79; 80)
+  FN_DEF@[80; 134)
+    FN_KW@[80; 82)
+    WHITESPACE@[82; 83)
+    NAME@[83; 86)
+      IDENT@[83; 86) "bar"
+    TYPE_PARAM_LIST@[86; 89)
+      L_ANGLE@[86; 87)
+      TYPE_PARAM@[87; 88)
+        NAME@[87; 88)
+          IDENT@[87; 88) "T"
+      R_ANGLE@[88; 89)
+    PARAM_LIST@[89; 97)
+      L_PAREN@[89; 90)
+      PARAM@[90; 96)
+        BIND_PAT@[90; 92)
+          NAME@[90; 92)
+            IDENT@[90; 92) "_t"
+        COLON@[92; 93)
+        WHITESPACE@[93; 94)
+        REFERENCE_TYPE@[94; 96)
+          AMP@[94; 95)
+          PATH_TYPE@[95; 96)
+            PATH@[95; 96)
+              PATH_SEGMENT@[95; 96)
+                NAME_REF@[95; 96)
+                  IDENT@[95; 96) "T"
+      R_PAREN@[96; 97)
+    WHITESPACE@[97; 98)
+    WHERE_CLAUSE@[98; 131)
+      WHERE_KW@[98; 103)
+      WHITESPACE@[103; 104)
+      WHERE_PRED@[104; 131)
+        FOR_TYPE@[104; 121)
+          FOR_KW@[104; 107)
+          TYPE_PARAM_LIST@[107; 111)
+            L_ANGLE@[107; 108)
+            LIFETIME_PARAM@[108; 110)
+              LIFETIME@[108; 110) "'a"
+            R_ANGLE@[110; 111)
+          WHITESPACE@[111; 112)
+          REFERENCE_TYPE@[112; 121)
+            AMP@[112; 113)
+            LIFETIME@[113; 115) "'a"
+            WHITESPACE@[115; 116)
+            MUT_KW@[116; 119)
+            WHITESPACE@[119; 120)
+            PATH_TYPE@[120; 121)
+              PATH@[120; 121)
+                PATH_SEGMENT@[120; 121)
+                  NAME_REF@[120; 121)
+                    IDENT@[120; 121) "T"
+        COLON@[121; 122)
+        WHITESPACE@[122; 123)
+        PATH_TYPE@[123; 131)
+          PATH@[123; 131)
+            PATH_SEGMENT@[123; 131)
+              NAME_REF@[123; 131)
+                IDENT@[123; 131) "Iterator"
+    WHITESPACE@[131; 132)
+    BLOCK@[132; 134)
+      L_CURLY@[132; 133)
+      R_CURLY@[133; 134)
+  WHITESPACE@[134; 135)