6 files changed, 259 insertions, 26 deletions

diff --git a/crates/syntax/src/algo.rs b/crates/syntax/src/algo.rs
index a153a9e1c..c9229c4e0 100644
--- a/crates/syntax/src/algo.rs
+++ b/crates/syntax/src/algo.rs
@@ -342,10 +342,10 @@ enum InsertPos {
 
 #[derive(Default)]
 pub struct SyntaxRewriter<'a> {
-    f: Option<Box<dyn Fn(&SyntaxElement) -> Option<SyntaxElement> + 'a>>,
     //FIXME: add debug_assertions that all elements are in fact from the same file.
     replacements: FxHashMap<SyntaxElement, Replacement>,
     insertions: IndexMap<InsertPos, Vec<SyntaxElement>>,
+    _pd: std::marker::PhantomData<&'a ()>,
 }
 
 impl fmt::Debug for SyntaxRewriter<'_> {
@@ -357,14 +357,7 @@ impl fmt::Debug for SyntaxRewriter<'_> {
     }
 }
 
-impl<'a> SyntaxRewriter<'a> {
-    pub fn from_fn(f: impl Fn(&SyntaxElement) -> Option<SyntaxElement> + 'a) -> SyntaxRewriter<'a> {
-        SyntaxRewriter {
-            f: Some(Box::new(f)),
-            replacements: FxHashMap::default(),
-            insertions: IndexMap::default(),
-        }
-    }
+impl SyntaxRewriter<'_> {
     pub fn delete<T: Clone + Into<SyntaxElement>>(&mut self, what: &T) {
         let what = what.clone().into();
         let replacement = Replacement::Delete;
@@ -470,7 +463,7 @@ impl<'a> SyntaxRewriter<'a> {
     pub fn rewrite(&self, node: &SyntaxNode) -> SyntaxNode {
         let _p = profile::span("rewrite");
 
-        if self.f.is_none() && self.replacements.is_empty() && self.insertions.is_empty() {
+        if self.replacements.is_empty() && self.insertions.is_empty() {
             return node.clone();
         }
         let green = self.rewrite_children(node);
@@ -495,7 +488,6 @@ impl<'a> SyntaxRewriter<'a> {
             }
         }
 
-        assert!(self.f.is_none());
         self.replacements
             .keys()
             .filter_map(element_to_node_or_parent)
@@ -510,10 +502,6 @@ impl<'a> SyntaxRewriter<'a> {
     }
 
     fn replacement(&self, element: &SyntaxElement) -> Option<Replacement> {
-        if let Some(f) = &self.f {
-            assert!(self.replacements.is_empty());
-            return f(element).map(Replacement::Single);
-        }
         self.replacements.get(element).cloned()
     }
 
@@ -574,7 +562,6 @@ fn element_to_green(element: SyntaxElement) -> NodeOrToken<rowan::GreenNode, row
 
 impl ops::AddAssign for SyntaxRewriter<'_> {
     fn add_assign(&mut self, rhs: SyntaxRewriter) {
-        assert!(rhs.f.is_none());
         self.replacements.extend(rhs.replacements);
         for (pos, insertions) in rhs.insertions.into_iter() {
             match self.insertions.entry(pos) {
diff --git a/crates/syntax/src/ast/edit_in_place.rs b/crates/syntax/src/ast/edit_in_place.rs
index 529bd0eb1..04f97f368 100644
--- a/crates/syntax/src/ast/edit_in_place.rs
+++ b/crates/syntax/src/ast/edit_in_place.rs
@@ -14,10 +14,29 @@ use crate::{
 use super::NameOwner;
 
 pub trait GenericParamsOwnerEdit: ast::GenericParamsOwner + AstNodeEdit {
+    fn get_or_create_generic_param_list(&self) -> ast::GenericParamList;
     fn get_or_create_where_clause(&self) -> ast::WhereClause;
 }
 
 impl GenericParamsOwnerEdit for ast::Fn {
+    fn get_or_create_generic_param_list(&self) -> ast::GenericParamList {
+        match self.generic_param_list() {
+            Some(it) => it,
+            None => {
+                let position = if let Some(name) = self.name() {
+                    Position::after(name.syntax)
+                } else if let Some(fn_token) = self.fn_token() {
+                    Position::after(fn_token)
+                } else if let Some(param_list) = self.param_list() {
+                    Position::before(param_list.syntax)
+                } else {
+                    Position::last_child_of(self.syntax())
+                };
+                create_generic_param_list(position)
+            }
+        }
+    }
+
     fn get_or_create_where_clause(&self) -> WhereClause {
         if self.where_clause().is_none() {
             let position = if let Some(ty) = self.ret_type() {
@@ -34,6 +53,20 @@ impl GenericParamsOwnerEdit for ast::Fn {
 }
 
 impl GenericParamsOwnerEdit for ast::Impl {
+    fn get_or_create_generic_param_list(&self) -> ast::GenericParamList {
+        match self.generic_param_list() {
+            Some(it) => it,
+            None => {
+                let position = if let Some(imp_token) = self.impl_token() {
+                    Position::after(imp_token)
+                } else {
+                    Position::last_child_of(self.syntax())
+                };
+                create_generic_param_list(position)
+            }
+        }
+    }
+
     fn get_or_create_where_clause(&self) -> WhereClause {
         if self.where_clause().is_none() {
             let position = if let Some(items) = self.assoc_item_list() {
@@ -48,6 +81,22 @@ impl GenericParamsOwnerEdit for ast::Impl {
 }
 
 impl GenericParamsOwnerEdit for ast::Trait {
+    fn get_or_create_generic_param_list(&self) -> ast::GenericParamList {
+        match self.generic_param_list() {
+            Some(it) => it,
+            None => {
+                let position = if let Some(name) = self.name() {
+                    Position::after(name.syntax)
+                } else if let Some(trait_token) = self.trait_token() {
+                    Position::after(trait_token)
+                } else {
+                    Position::last_child_of(self.syntax())
+                };
+                create_generic_param_list(position)
+            }
+        }
+    }
+
     fn get_or_create_where_clause(&self) -> WhereClause {
         if self.where_clause().is_none() {
             let position = if let Some(items) = self.assoc_item_list() {
@@ -62,6 +111,22 @@ impl GenericParamsOwnerEdit for ast::Trait {
 }
 
 impl GenericParamsOwnerEdit for ast::Struct {
+    fn get_or_create_generic_param_list(&self) -> ast::GenericParamList {
+        match self.generic_param_list() {
+            Some(it) => it,
+            None => {
+                let position = if let Some(name) = self.name() {
+                    Position::after(name.syntax)
+                } else if let Some(struct_token) = self.struct_token() {
+                    Position::after(struct_token)
+                } else {
+                    Position::last_child_of(self.syntax())
+                };
+                create_generic_param_list(position)
+            }
+        }
+    }
+
     fn get_or_create_where_clause(&self) -> WhereClause {
         if self.where_clause().is_none() {
             let tfl = self.field_list().and_then(|fl| match fl {
@@ -84,6 +149,22 @@ impl GenericParamsOwnerEdit for ast::Struct {
 }
 
 impl GenericParamsOwnerEdit for ast::Enum {
+    fn get_or_create_generic_param_list(&self) -> ast::GenericParamList {
+        match self.generic_param_list() {
+            Some(it) => it,
+            None => {
+                let position = if let Some(name) = self.name() {
+                    Position::after(name.syntax)
+                } else if let Some(enum_token) = self.enum_token() {
+                    Position::after(enum_token)
+                } else {
+                    Position::last_child_of(self.syntax())
+                };
+                create_generic_param_list(position)
+            }
+        }
+    }
+
     fn get_or_create_where_clause(&self) -> WhereClause {
         if self.where_clause().is_none() {
             let position = if let Some(gpl) = self.generic_param_list() {
@@ -104,6 +185,37 @@ fn create_where_clause(position: Position) {
     ted::insert(position, where_clause.syntax());
 }
 
+fn create_generic_param_list(position: Position) -> ast::GenericParamList {
+    let gpl = make::generic_param_list(empty()).clone_for_update();
+    ted::insert_raw(position, gpl.syntax());
+    gpl
+}
+
+impl ast::GenericParamList {
+    pub fn add_generic_param(&self, generic_param: ast::GenericParam) {
+        match self.generic_params().last() {
+            Some(last_param) => {
+                let mut elems = Vec::new();
+                if !last_param
+                    .syntax()
+                    .siblings_with_tokens(Direction::Next)
+                    .any(|it| it.kind() == T![,])
+                {
+                    elems.push(make::token(T![,]).into());
+                    elems.push(make::tokens::single_space().into());
+                };
+                elems.push(generic_param.syntax().clone().into());
+                let after_last_param = Position::after(last_param.syntax());
+                ted::insert_all(after_last_param, elems);
+            }
+            None => {
+                let after_l_angle = Position::after(self.l_angle_token().unwrap());
+                ted::insert(after_l_angle, generic_param.syntax())
+            }
+        }
+    }
+}
+
 impl ast::WhereClause {
     pub fn add_predicate(&self, predicate: ast::WherePred) {
         if let Some(pred) = self.predicates().last() {
@@ -164,3 +276,44 @@ impl ast::Use {
         ted::remove(self.syntax())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::fmt;
+
+    use crate::SourceFile;
+
+    use super::*;
+
+    fn ast_mut_from_text<N: AstNode>(text: &str) -> N {
+        let parse = SourceFile::parse(text);
+        parse.tree().syntax().descendants().find_map(N::cast).unwrap().clone_for_update()
+    }
+
+    #[test]
+    fn test_create_generic_param_list() {
+        fn check_create_gpl<N: GenericParamsOwnerEdit + fmt::Display>(before: &str, after: &str) {
+            let gpl_owner = ast_mut_from_text::<N>(before);
+            gpl_owner.get_or_create_generic_param_list();
+            assert_eq!(gpl_owner.to_string(), after);
+        }
+
+        check_create_gpl::<ast::Fn>("fn foo", "fn foo<>");
+        check_create_gpl::<ast::Fn>("fn foo() {}", "fn foo<>() {}");
+
+        check_create_gpl::<ast::Impl>("impl", "impl<>");
+        check_create_gpl::<ast::Impl>("impl Struct {}", "impl<> Struct {}");
+        check_create_gpl::<ast::Impl>("impl Trait for Struct {}", "impl<> Trait for Struct {}");
+
+        check_create_gpl::<ast::Trait>("trait Trait<>", "trait Trait<>");
+        check_create_gpl::<ast::Trait>("trait Trait<> {}", "trait Trait<> {}");
+
+        check_create_gpl::<ast::Struct>("struct A", "struct A<>");
+        check_create_gpl::<ast::Struct>("struct A;", "struct A<>;");
+        check_create_gpl::<ast::Struct>("struct A();", "struct A<>();");
+        check_create_gpl::<ast::Struct>("struct A {}", "struct A<> {}");
+
+        check_create_gpl::<ast::Enum>("enum E", "enum E<>");
+        check_create_gpl::<ast::Enum>("enum E {", "enum E<> {");
+    }
+}
diff --git a/crates/syntax/src/ast/make.rs b/crates/syntax/src/ast/make.rs
index c6a7b99b7..42da09606 100644
--- a/crates/syntax/src/ast/make.rs
+++ b/crates/syntax/src/ast/make.rs
@@ -29,9 +29,13 @@ pub fn ty(text: &str) -> ast::Type {
 pub fn ty_unit() -> ast::Type {
     ty("()")
 }
-// FIXME: handle types of length == 1
 pub fn ty_tuple(types: impl IntoIterator<Item = ast::Type>) -> ast::Type {
-    let contents = types.into_iter().join(", ");
+    let mut count: usize = 0;
+    let mut contents = types.into_iter().inspect(|_| count += 1).join(", ");
+    if count == 1 {
+        contents.push(',');
+    }
+
     ty(&format!("({})", contents))
 }
 // FIXME: handle path to type
@@ -133,6 +137,17 @@ pub fn use_(visibility: Option<ast::Visibility>, use_tree: ast::UseTree) -> ast:
     ast_from_text(&format!("{}use {};", visibility, use_tree))
 }
 
+pub fn record_expr(path: ast::Path, fields: ast::RecordExprFieldList) -> ast::RecordExpr {
+    ast_from_text(&format!("fn f() {{ {} {} }}", path, fields))
+}
+
+pub fn record_expr_field_list(
+    fields: impl IntoIterator<Item = ast::RecordExprField>,
+) -> ast::RecordExprFieldList {
+    let fields = fields.into_iter().join(", ");
+    ast_from_text(&format!("fn f() {{ S {{ {} }} }}", fields))
+}
+
 pub fn record_expr_field(name: ast::NameRef, expr: Option<ast::Expr>) -> ast::RecordExprField {
     return match expr {
         Some(expr) => from_text(&format!("{}: {}", name, expr)),
@@ -290,13 +305,23 @@ pub fn wildcard_pat() -> ast::WildcardPat {
     }
 }
 
+pub fn literal_pat(lit: &str) -> ast::LiteralPat {
+    return from_text(lit);
+
+    fn from_text(text: &str) -> ast::LiteralPat {
+        ast_from_text(&format!("fn f() {{ match x {{ {} => {{}} }} }}", text))
+    }
+}
+
 /// Creates a tuple of patterns from an iterator of patterns.
 ///
-/// Invariant: `pats` must be length > 1
-///
-/// FIXME handle `pats` length == 1
+/// Invariant: `pats` must be length > 0
 pub fn tuple_pat(pats: impl IntoIterator<Item = ast::Pat>) -> ast::TuplePat {
-    let pats_str = pats.into_iter().map(|p| p.to_string()).join(", ");
+    let mut count: usize = 0;
+    let mut pats_str = pats.into_iter().inspect(|_| count += 1).join(", ");
+    if count == 1 {
+        pats_str.push(',');
+    }
     return from_text(&format!("({})", pats_str));
 
     fn from_text(text: &str) -> ast::TuplePat {
@@ -325,6 +350,21 @@ pub fn record_pat(path: ast::Path, pats: impl IntoIterator<Item = ast::Pat>) ->
     }
 }
 
+pub fn record_pat_with_fields(path: ast::Path, fields: ast::RecordPatFieldList) -> ast::RecordPat {
+    ast_from_text(&format!("fn f({} {}: ()))", path, fields))
+}
+
+pub fn record_pat_field_list(
+    fields: impl IntoIterator<Item = ast::RecordPatField>,
+) -> ast::RecordPatFieldList {
+    let fields = fields.into_iter().join(", ");
+    ast_from_text(&format!("fn f(S {{ {} }}: ()))", fields))
+}
+
+pub fn record_pat_field(name_ref: ast::NameRef, pat: ast::Pat) -> ast::RecordPatField {
+    ast_from_text(&format!("fn f(S {{ {}: {} }}: ()))", name_ref, pat))
+}
+
 /// Returns a `BindPat` if the path has just one segment, a `PathPat` otherwise.
 pub fn path_pat(path: ast::Path) -> ast::Pat {
     return from_text(&path.to_string());
@@ -592,6 +632,7 @@ pub mod tokens {
         SOURCE_FILE
             .tree()
             .syntax()
+            .clone_for_update()
             .descendants_with_tokens()
             .filter_map(|it| it.into_token())
             .find(|it| it.kind() == WHITESPACE && it.text() == "\n\n")
diff --git a/crates/syntax/src/ast/node_ext.rs b/crates/syntax/src/ast/node_ext.rs
index ae98dbd26..492fbc4a0 100644
--- a/crates/syntax/src/ast/node_ext.rs
+++ b/crates/syntax/src/ast/node_ext.rs
@@ -1,7 +1,7 @@
 //! Various extension methods to ast Nodes, which are hard to code-generate.
 //! Extensions for various expressions live in a sibling `expr_extensions` module.
 
-use std::fmt;
+use std::{fmt, iter::successors};
 
 use itertools::Itertools;
 use parser::SyntaxKind;
@@ -125,6 +125,18 @@ pub enum AttrKind {
     Outer,
 }
 
+impl AttrKind {
+    /// Returns `true` if the attr_kind is [`Inner`].
+    pub fn is_inner(&self) -> bool {
+        matches!(self, Self::Inner)
+    }
+
+    /// Returns `true` if the attr_kind is [`Outer`].
+    pub fn is_outer(&self) -> bool {
+        matches!(self, Self::Outer)
+    }
+}
+
 impl ast::Attr {
     pub fn as_simple_atom(&self) -> Option<SmolStr> {
         if self.eq_token().is_some() || self.token_tree().is_some() {
@@ -225,6 +237,26 @@ impl ast::Path {
             None => self.segment(),
         }
     }
+
+    pub fn first_qualifier_or_self(&self) -> ast::Path {
+        successors(Some(self.clone()), ast::Path::qualifier).last().unwrap()
+    }
+
+    pub fn first_segment(&self) -> Option<ast::PathSegment> {
+        self.first_qualifier_or_self().segment()
+    }
+
+    pub fn segments(&self) -> impl Iterator<Item = ast::PathSegment> + Clone {
+        // cant make use of SyntaxNode::siblings, because the returned Iterator is not clone
+        successors(self.first_segment(), |p| {
+            p.parent_path().parent_path().and_then(|p| p.segment())
+        })
+    }
+}
+impl ast::UseTree {
+    pub fn is_simple_path(&self) -> bool {
+        self.use_tree_list().is_none() && self.star_token().is_none()
+    }
 }
 
 impl ast::UseTreeList {
diff --git a/crates/syntax/src/ted.rs b/crates/syntax/src/ted.rs
index 177d4ff67..91a06101f 100644
--- a/crates/syntax/src/ted.rs
+++ b/crates/syntax/src/ted.rs
@@ -7,7 +7,7 @@ use std::{mem, ops::RangeInclusive};
 use parser::T;
 
 use crate::{
-    ast::{edit::IndentLevel, make},
+    ast::{self, edit::IndentLevel, make, AstNode},
     SyntaxElement, SyntaxKind, SyntaxNode, SyntaxToken,
 };
 
@@ -147,6 +147,16 @@ pub fn append_child_raw(node: &(impl Into<SyntaxNode> + Clone), child: impl Elem
 fn ws_before(position: &Position, new: &SyntaxElement) -> Option<SyntaxToken> {
     let prev = match &position.repr {
         PositionRepr::FirstChild(_) => return None,
+        PositionRepr::After(it) if it.kind() == SyntaxKind::L_CURLY => {
+            if new.kind() == SyntaxKind::USE {
+                if let Some(item_list) = it.parent().and_then(ast::ItemList::cast) {
+                    let mut indent = IndentLevel::from_element(&item_list.syntax().clone().into());
+                    indent.0 += 1;
+                    return Some(make::tokens::whitespace(&format!("\n{}", indent)));
+                }
+            }
+            it
+        }
         PositionRepr::After(it) => it,
     };
     ws_between(prev, new)
@@ -165,8 +175,18 @@ fn ws_between(left: &SyntaxElement, right: &SyntaxElement) -> Option<SyntaxToken
     if right.kind() == T![;] || right.kind() == T![,] {
         return None;
     }
+    if left.kind() == T![<] || right.kind() == T![>] {
+        return None;
+    }
+    if left.kind() == T![&] && right.kind() == SyntaxKind::LIFETIME {
+        return None;
+    }
+
     if right.kind() == SyntaxKind::USE {
-        let indent = IndentLevel::from_element(left);
+        let mut indent = IndentLevel::from_element(left);
+        if left.kind() == SyntaxKind::USE {
+            indent.0 = IndentLevel::from_element(right).0.max(indent.0);
+        }
         return Some(make::tokens::whitespace(&format!("\n{}", indent)));
     }
     Some(make::tokens::single_space())
diff --git a/crates/syntax/src/validation/block.rs b/crates/syntax/src/validation/block.rs
index ad9901468..40170014f 100644
--- a/crates/syntax/src/validation/block.rs
+++ b/crates/syntax/src/validation/block.rs
@@ -13,7 +13,7 @@ pub(crate) fn validate_block_expr(block: ast::BlockExpr, errors: &mut Vec<Syntax
             _ => {}
         }
     }
-    errors.extend(block.attrs().map(|attr| {
+    errors.extend(block.attrs().filter(|attr| attr.kind().is_inner()).map(|attr| {
         SyntaxError::new(
             "A block in this position cannot accept inner attributes",
             attr.syntax().text_range(),