7 files changed, 68 insertions, 17 deletions

diff --git a/crates/ra_syntax/src/algo.rs b/crates/ra_syntax/src/algo.rs
index 1c075082a..e4061e994 100644
--- a/crates/ra_syntax/src/algo.rs
+++ b/crates/ra_syntax/src/algo.rs
@@ -140,13 +140,13 @@ pub fn insert_children(
     });
 
     let new_children = match &position {
-        InsertPosition::First => to_insert.chain(old_children).collect::<Box<[_]>>(),
-        InsertPosition::Last => old_children.chain(to_insert).collect::<Box<[_]>>(),
+        InsertPosition::First => to_insert.chain(old_children).collect::<Vec<_>>(),
+        InsertPosition::Last => old_children.chain(to_insert).collect::<Vec<_>>(),
         InsertPosition::Before(anchor) | InsertPosition::After(anchor) => {
             let take_anchor = if let InsertPosition::After(_) = position { 1 } else { 0 };
             let split_at = position_of_child(parent, anchor.clone()) + take_anchor;
             let before = old_children.by_ref().take(split_at).collect::<Vec<_>>();
-            before.into_iter().chain(to_insert).chain(old_children).collect::<Box<[_]>>()
+            before.into_iter().chain(to_insert).chain(old_children).collect::<Vec<_>>()
         }
     };
 
@@ -174,7 +174,7 @@ pub fn replace_children(
         .into_iter()
         .chain(to_insert.map(to_green_element))
         .chain(old_children.skip(end + 1 - start))
-        .collect::<Box<[_]>>();
+        .collect::<Vec<_>>();
     with_children(parent, new_children)
 }
 
@@ -187,7 +187,7 @@ pub fn replace_descendants(
     map: &FxHashMap<SyntaxElement, SyntaxElement>,
 ) -> SyntaxNode {
     //  FIXME: this could be made much faster.
-    let new_children = parent.children_with_tokens().map(|it| go(map, it)).collect::<Box<[_]>>();
+    let new_children = parent.children_with_tokens().map(|it| go(map, it)).collect::<Vec<_>>();
     return with_children(parent, new_children);
 
     fn go(
@@ -211,7 +211,7 @@ pub fn replace_descendants(
 
 fn with_children(
     parent: &SyntaxNode,
-    new_children: Box<[NodeOrToken<rowan::GreenNode, rowan::GreenToken>]>,
+    new_children: Vec<NodeOrToken<rowan::GreenNode, rowan::GreenToken>>,
 ) -> SyntaxNode {
     let len = new_children.iter().map(|it| it.text_len()).sum::<TextUnit>();
     let new_node =
diff --git a/crates/ra_syntax/src/ast/edit.rs b/crates/ra_syntax/src/ast/edit.rs
index 95bf9db14..ae5d63927 100644
--- a/crates/ra_syntax/src/ast/edit.rs
+++ b/crates/ra_syntax/src/ast/edit.rs
@@ -104,7 +104,7 @@ impl ast::ItemList {
             }
         };
 
-        let indent = leading_indent(self.syntax()).unwrap_or("".into());
+        let indent = leading_indent(self.syntax()).unwrap_or_default();
         let ws = tokens::WsBuilder::new(&format!("\n{}", indent));
         let to_insert = iter::once(ws.ws().into());
         match existing_ws {
@@ -133,7 +133,7 @@ impl ast::RecordFieldList {
         let space = if is_multiline {
             ws = tokens::WsBuilder::new(&format!(
                 "\n{}    ",
-                leading_indent(self.syntax()).unwrap_or("".into())
+                leading_indent(self.syntax()).unwrap_or_default()
             ));
             ws.ws()
         } else {
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index c06076e3d..9f9d6e63c 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -312,6 +312,7 @@ impl AstNode for Block {
     }
 }
 impl ast::AttrsOwner for Block {}
+impl ast::ModuleItemOwner for Block {}
 impl Block {
     pub fn statements(&self) -> AstChildren<Stmt> {
         AstChildren::new(&self.syntax)
@@ -550,6 +551,36 @@ impl ConstDef {
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ConstParam {
+    pub(crate) syntax: SyntaxNode,
+}
+impl AstNode for ConstParam {
+    fn can_cast(kind: SyntaxKind) -> bool {
+        match kind {
+            CONST_PARAM => true,
+            _ => false,
+        }
+    }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl ast::NameOwner for ConstParam {}
+impl ast::AttrsOwner for ConstParam {}
+impl ast::TypeAscriptionOwner for ConstParam {}
+impl ConstParam {
+    pub fn default_val(&self) -> Option<Expr> {
+        AstChildren::new(&self.syntax).next()
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ContinueExpr {
     pub(crate) syntax: SyntaxNode,
 }
@@ -1425,6 +1456,9 @@ impl LambdaExpr {
     pub fn param_list(&self) -> Option<ParamList> {
         AstChildren::new(&self.syntax).next()
     }
+    pub fn ret_type(&self) -> Option<RetType> {
+        AstChildren::new(&self.syntax).next()
+    }
     pub fn body(&self) -> Option<Expr> {
         AstChildren::new(&self.syntax).next()
     }
diff --git a/crates/ra_syntax/src/ast/make.rs b/crates/ra_syntax/src/ast/make.rs
index 40db570da..04a5408fe 100644
--- a/crates/ra_syntax/src/ast/make.rs
+++ b/crates/ra_syntax/src/ast/make.rs
@@ -168,8 +168,7 @@ pub fn let_stmt(pattern: ast::Pat, initializer: Option<ast::Expr>) -> ast::LetSt
 
 fn ast_from_text<N: AstNode>(text: &str) -> N {
     let parse = SourceFile::parse(text);
-    let res = parse.tree().syntax().descendants().find_map(N::cast).unwrap();
-    res
+    parse.tree().syntax().descendants().find_map(N::cast).unwrap()
 }
 
 pub mod tokens {
diff --git a/crates/ra_syntax/src/grammar.ron b/crates/ra_syntax/src/grammar.ron
index d1be40abe..08aafb610 100644
--- a/crates/ra_syntax/src/grammar.ron
+++ b/crates/ra_syntax/src/grammar.ron
@@ -94,7 +94,8 @@ Grammar(
         "return",
         "try",
         "box",
-        "await"
+        "await",
+        "macro"
     ],
     contextual_keywords: [
         "auto",
@@ -140,6 +141,7 @@ Grammar(
         "TYPE_ALIAS_DEF",
         "MACRO_CALL",
         "TOKEN_TREE",
+        "MACRO_DEF",
 
         "PAREN_TYPE",
         "TUPLE_TYPE",
@@ -243,6 +245,7 @@ Grammar(
         "TYPE_PARAM_LIST",
         "LIFETIME_PARAM",
         "TYPE_PARAM",
+        "CONST_PARAM",
         "TYPE_ARG_LIST",
         "LIFETIME_ARG",
         "TYPE_ARG",
@@ -426,7 +429,7 @@ Grammar(
         "PathExpr": (options: ["Path"]),
         "LambdaExpr": (
             options: [
-                "ParamList",
+                "ParamList", "RetType",
                 ["body", "Expr"],
             ]
         ),
@@ -602,6 +605,10 @@ Grammar(
             options: [("default_type", "TypeRef")],
             traits: ["NameOwner", "AttrsOwner", "TypeBoundsOwner"],
         ),
+        "ConstParam": (
+            options: [("default_val", "Expr")],
+            traits: ["NameOwner", "AttrsOwner", "TypeAscriptionOwner"],
+        ),
         "LifetimeParam": (
             traits: ["AttrsOwner"],
         ),
@@ -653,6 +660,7 @@ Grammar(
             ],
             traits: [
                 "AttrsOwner",
+                "ModuleItemOwner",
             ]
         ),
         "ParamList": (
@@ -664,14 +672,14 @@ Grammar(
         "SelfParam": (
             traits: [
                 "TypeAscriptionOwner",
-                                "AttrsOwner",
+                "AttrsOwner",
             ]
         ),
         "Param": (
             options: [ "Pat" ],
             traits: [
                 "TypeAscriptionOwner",
-                                "AttrsOwner",
+                "AttrsOwner",
             ]
         ),
         "UseItem": (
diff --git a/crates/ra_syntax/src/ptr.rs b/crates/ra_syntax/src/ptr.rs
index e049fce61..db6230aab 100644
--- a/crates/ra_syntax/src/ptr.rs
+++ b/crates/ra_syntax/src/ptr.rs
@@ -1,6 +1,10 @@
 //! FIXME: write short doc here
 
-use std::{iter::successors, marker::PhantomData};
+use std::{
+    hash::{Hash, Hasher},
+    iter::successors,
+    marker::PhantomData,
+};
 
 use crate::{AstNode, SyntaxKind, SyntaxNode, TextRange};
 
@@ -43,7 +47,7 @@ impl SyntaxNodePtr {
 }
 
 /// Like `SyntaxNodePtr`, but remembers the type of node
-#[derive(Debug, Hash)]
+#[derive(Debug)]
 pub struct AstPtr<N: AstNode> {
     raw: SyntaxNodePtr,
     _ty: PhantomData<fn() -> N>,
@@ -64,6 +68,12 @@ impl<N: AstNode> PartialEq for AstPtr<N> {
     }
 }
 
+impl<N: AstNode> Hash for AstPtr<N> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.raw.hash(state)
+    }
+}
+
 impl<N: AstNode> AstPtr<N> {
     pub fn new(node: &N) -> AstPtr<N> {
         AstPtr { raw: SyntaxNodePtr::new(node.syntax()), _ty: PhantomData }
diff --git a/crates/ra_syntax/src/syntax_node.rs b/crates/ra_syntax/src/syntax_node.rs
index b2f5b8c64..041c6ea8d 100644
--- a/crates/ra_syntax/src/syntax_node.rs
+++ b/crates/ra_syntax/src/syntax_node.rs
@@ -40,7 +40,7 @@ pub use rowan::{Direction, NodeOrToken};
 
 pub struct SyntaxTreeBuilder {
     errors: Vec<SyntaxError>,
-    inner: GreenNodeBuilder,
+    inner: GreenNodeBuilder<'static>,
 }
 
 impl Default for SyntaxTreeBuilder {