11 files changed, 774 insertions, 36 deletions

diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs
index bcbd4c60c..165b308d1 100644
--- a/crates/ra_syntax/src/ast.rs
+++ b/crates/ra_syntax/src/ast.rs
@@ -15,12 +15,13 @@ use crate::{
 /// conversion itself has zero runtime cost: ast and syntax nodes have exactly
 /// the same representation: a pointer to the tree root and a pointer to the
 /// node itself.
-pub trait AstNode: rowan::TransparentNewType<Repr = rowan::SyntaxNode<RaTypes>> {
+pub trait AstNode:
+    rowan::TransparentNewType<Repr = rowan::SyntaxNode<RaTypes>> + ToOwned<Owned = TreeArc<Self>>
+{
     fn cast(syntax: &SyntaxNode) -> Option<&Self>
     where
         Self: Sized;
     fn syntax(&self) -> &SyntaxNode;
-    fn to_owned(&self) -> TreeArc<Self>;
 }
 
 pub trait AstToken: AstNode {
@@ -430,6 +431,13 @@ impl StructDef {
 }
 
 impl EnumVariant {
+    pub fn parent_enum(&self) -> &EnumDef {
+        self.syntax()
+            .parent()
+            .and_then(|it| it.parent())
+            .and_then(EnumDef::cast)
+            .expect("EnumVariants are always nested in Enums")
+    }
     pub fn flavor(&self) -> StructFlavor {
         StructFlavor::from_node(self)
     }
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index be16511df..7da19d782 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -35,6 +35,10 @@ impl AstNode for ArgList {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for ArgList {
+    type Owned = TreeArc<ArgList>;
     fn to_owned(&self) -> TreeArc<ArgList> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -63,6 +67,10 @@ impl AstNode for ArrayExpr {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for ArrayExpr {
+    type Owned = TreeArc<ArrayExpr>;
     fn to_owned(&self) -> TreeArc<ArrayExpr> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -91,6 +99,10 @@ impl AstNode for ArrayType {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for ArrayType {
+    type Owned = TreeArc<ArrayType>;
     fn to_owned(&self) -> TreeArc<ArrayType> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -123,6 +135,10 @@ impl AstNode for AssocTypeArg {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for AssocTypeArg {
+    type Owned = TreeArc<AssocTypeArg>;
     fn to_owned(&self) -> TreeArc<AssocTypeArg> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -155,6 +171,10 @@ impl AstNode for Attr {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for Attr {
+    type Owned = TreeArc<Attr>;
     fn to_owned(&self) -> TreeArc<Attr> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -183,6 +203,10 @@ impl AstNode for BinExpr {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for BinExpr {
+    type Owned = TreeArc<BinExpr>;
     fn to_owned(&self) -> TreeArc<BinExpr> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -207,6 +231,10 @@ impl AstNode for BindPat {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for BindPat {
+    type Owned = TreeArc<BindPat>;
     fn to_owned(&self) -> TreeArc<BindPat> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -236,6 +264,10 @@ impl AstNode for Block {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for Block {
+    type Owned = TreeArc<Block>;
     fn to_owned(&self) -> TreeArc<Block> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -268,6 +300,10 @@ impl AstNode for BlockExpr {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for BlockExpr {
+    type Owned = TreeArc<BlockExpr>;
     fn to_owned(&self) -> TreeArc<BlockExpr> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -296,6 +332,10 @@ impl AstNode for BreakExpr {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for BreakExpr {
+    type Owned = TreeArc<BreakExpr>;
     fn to_owned(&self) -> TreeArc<BreakExpr> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -324,6 +364,10 @@ impl AstNode for Byte {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for Byte {
+    type Owned = TreeArc<Byte>;
     fn to_owned(&self) -> TreeArc<Byte> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -349,6 +393,10 @@ impl AstNode for ByteString {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for ByteString {
+    type Owned = TreeArc<ByteString>;
     fn to_owned(&self) -> TreeArc<ByteString> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -374,6 +422,10 @@ impl AstNode for CallExpr {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for CallExpr {
+    type Owned = TreeArc<CallExpr>;
     fn to_owned(&self) -> TreeArc<CallExpr> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -403,6 +455,10 @@ impl AstNode for CastExpr {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for CastExpr {
+    type Owned = TreeArc<CastExpr>;
     fn to_owned(&self) -> TreeArc<CastExpr> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -435,6 +491,10 @@ impl AstNode for Char {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for Char {
+    type Owned = TreeArc<Char>;
     fn to_owned(&self) -> TreeArc<Char> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -460,6 +520,10 @@ impl AstNode for Comment {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for Comment {
+    type Owned = TreeArc<Comment>;
     fn to_owned(&self) -> TreeArc<Comment> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -485,6 +549,10 @@ impl AstNode for Condition {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for Condition {
+    type Owned = TreeArc<Condition>;
     fn to_owned(&self) -> TreeArc<Condition> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -517,6 +585,10 @@ impl AstNode for ConstDef {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for ConstDef {
+    type Owned = TreeArc<ConstDef>;
     fn to_owned(&self) -> TreeArc<ConstDef> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -550,6 +622,10 @@ impl AstNode for ContinueExpr {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for ContinueExpr {
+    type Owned = TreeArc<ContinueExpr>;
     fn to_owned(&self) -> TreeArc<ContinueExpr> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -574,6 +650,10 @@ impl AstNode for DynTraitType {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for DynTraitType {
+    type Owned = TreeArc<DynTraitType>;
     fn to_owned(&self) -> TreeArc<DynTraitType> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -598,6 +678,10 @@ impl AstNode for EnumDef {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for EnumDef {
+    type Owned = TreeArc<EnumDef>;
     fn to_owned(&self) -> TreeArc<EnumDef> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -631,6 +715,10 @@ impl AstNode for EnumVariant {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for EnumVariant {
+    type Owned = TreeArc<EnumVariant>;
     fn to_owned(&self) -> TreeArc<EnumVariant> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -661,6 +749,10 @@ impl AstNode for EnumVariantList {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for EnumVariantList {
+    type Owned = TreeArc<EnumVariantList>;
     fn to_owned(&self) -> TreeArc<EnumVariantList> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -746,6 +838,10 @@ impl AstNode for Expr {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for Expr {
+    type Owned = TreeArc<Expr>;
     fn to_owned(&self) -> TreeArc<Expr> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -804,6 +900,10 @@ impl AstNode for ExprStmt {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for ExprStmt {
+    type Owned = TreeArc<ExprStmt>;
     fn to_owned(&self) -> TreeArc<ExprStmt> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -832,6 +932,10 @@ impl AstNode for ExternCrateItem {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for ExternCrateItem {
+    type Owned = TreeArc<ExternCrateItem>;
     fn to_owned(&self) -> TreeArc<ExternCrateItem> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -856,6 +960,10 @@ impl AstNode for FalseKw {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for FalseKw {
+    type Owned = TreeArc<FalseKw>;
     fn to_owned(&self) -> TreeArc<FalseKw> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -881,6 +989,10 @@ impl AstNode for FieldExpr {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for FieldExpr {
+    type Owned = TreeArc<FieldExpr>;
     fn to_owned(&self) -> TreeArc<FieldExpr> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -913,6 +1025,10 @@ impl AstNode for FieldPat {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for FieldPat {
+    type Owned = TreeArc<FieldPat>;
     fn to_owned(&self) -> TreeArc<FieldPat> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -942,6 +1058,10 @@ impl AstNode for FieldPatList {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for FieldPatList {
+    type Owned = TreeArc<FieldPatList>;
     fn to_owned(&self) -> TreeArc<FieldPatList> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -974,6 +1094,10 @@ impl AstNode for FloatNumber {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for FloatNumber {
+    type Owned = TreeArc<FloatNumber>;
     fn to_owned(&self) -> TreeArc<FloatNumber> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -999,6 +1123,10 @@ impl AstNode for FnDef {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for FnDef {
+    type Owned = TreeArc<FnDef>;
     fn to_owned(&self) -> TreeArc<FnDef> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1040,6 +1168,10 @@ impl AstNode for FnPointerType {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for FnPointerType {
+    type Owned = TreeArc<FnPointerType>;
     fn to_owned(&self) -> TreeArc<FnPointerType> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1072,6 +1204,10 @@ impl AstNode for ForExpr {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for ForExpr {
+    type Owned = TreeArc<ForExpr>;
     fn to_owned(&self) -> TreeArc<ForExpr> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1105,6 +1241,10 @@ impl AstNode for ForType {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for ForType {
+    type Owned = TreeArc<ForType>;
     fn to_owned(&self) -> TreeArc<ForType> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1133,6 +1273,10 @@ impl AstNode for IfExpr {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for IfExpr {
+    type Owned = TreeArc<IfExpr>;
     fn to_owned(&self) -> TreeArc<IfExpr> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1161,6 +1305,10 @@ impl AstNode for ImplBlock {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for ImplBlock {
+    type Owned = TreeArc<ImplBlock>;
     fn to_owned(&self) -> TreeArc<ImplBlock> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1198,6 +1346,10 @@ impl AstNode for ImplItem {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for ImplItem {
+    type Owned = TreeArc<ImplItem>;
     fn to_owned(&self) -> TreeArc<ImplItem> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1232,6 +1384,10 @@ impl AstNode for ImplTraitType {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for ImplTraitType {
+    type Owned = TreeArc<ImplTraitType>;
     fn to_owned(&self) -> TreeArc<ImplTraitType> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1256,6 +1412,10 @@ impl AstNode for IndexExpr {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for IndexExpr {
+    type Owned = TreeArc<IndexExpr>;
     fn to_owned(&self) -> TreeArc<IndexExpr> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1280,6 +1440,10 @@ impl AstNode for IntNumber {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for IntNumber {
+    type Owned = TreeArc<IntNumber>;
     fn to_owned(&self) -> TreeArc<IntNumber> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1305,6 +1469,10 @@ impl AstNode for ItemList {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for ItemList {
+    type Owned = TreeArc<ItemList>;
     fn to_owned(&self) -> TreeArc<ItemList> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1335,6 +1503,10 @@ impl AstNode for Label {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for Label {
+    type Owned = TreeArc<Label>;
     fn to_owned(&self) -> TreeArc<Label> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1359,6 +1531,10 @@ impl AstNode for LambdaExpr {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for LambdaExpr {
+    type Owned = TreeArc<LambdaExpr>;
     fn to_owned(&self) -> TreeArc<LambdaExpr> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1391,6 +1567,10 @@ impl AstNode for LetStmt {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for LetStmt {
+    type Owned = TreeArc<LetStmt>;
     fn to_owned(&self) -> TreeArc<LetStmt> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1427,6 +1607,10 @@ impl AstNode for Lifetime {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for Lifetime {
+    type Owned = TreeArc<Lifetime>;
     fn to_owned(&self) -> TreeArc<Lifetime> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1452,6 +1636,10 @@ impl AstNode for LifetimeArg {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for LifetimeArg {
+    type Owned = TreeArc<LifetimeArg>;
     fn to_owned(&self) -> TreeArc<LifetimeArg> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1480,6 +1668,10 @@ impl AstNode for LifetimeParam {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for LifetimeParam {
+    type Owned = TreeArc<LifetimeParam>;
     fn to_owned(&self) -> TreeArc<LifetimeParam> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1508,6 +1700,10 @@ impl AstNode for Literal {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for Literal {
+    type Owned = TreeArc<Literal>;
     fn to_owned(&self) -> TreeArc<Literal> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1559,6 +1755,10 @@ impl AstNode for LiteralExpr {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for LiteralExpr {
+    type Owned = TreeArc<LiteralExpr>;
     fn to_owned(&self) -> TreeArc<LiteralExpr> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1600,6 +1800,10 @@ impl AstNode for LoopExpr {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for LoopExpr {
+    type Owned = TreeArc<LoopExpr>;
     fn to_owned(&self) -> TreeArc<LoopExpr> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1625,6 +1829,10 @@ impl AstNode for MacroCall {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for MacroCall {
+    type Owned = TreeArc<MacroCall>;
     fn to_owned(&self) -> TreeArc<MacroCall> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1657,6 +1865,10 @@ impl AstNode for MatchArm {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for MatchArm {
+    type Owned = TreeArc<MatchArm>;
     fn to_owned(&self) -> TreeArc<MatchArm> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1693,6 +1905,10 @@ impl AstNode for MatchArmList {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for MatchArmList {
+    type Owned = TreeArc<MatchArmList>;
     fn to_owned(&self) -> TreeArc<MatchArmList> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1721,6 +1937,10 @@ impl AstNode for MatchExpr {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for MatchExpr {
+    type Owned = TreeArc<MatchExpr>;
     fn to_owned(&self) -> TreeArc<MatchExpr> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1753,6 +1973,10 @@ impl AstNode for MatchGuard {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for MatchGuard {
+    type Owned = TreeArc<MatchGuard>;
     fn to_owned(&self) -> TreeArc<MatchGuard> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1777,6 +2001,10 @@ impl AstNode for MethodCallExpr {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for MethodCallExpr {
+    type Owned = TreeArc<MethodCallExpr>;
     fn to_owned(&self) -> TreeArc<MethodCallExpr> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1810,6 +2038,10 @@ impl AstNode for Module {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for Module {
+    type Owned = TreeArc<Module>;
     fn to_owned(&self) -> TreeArc<Module> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1867,6 +2099,10 @@ impl AstNode for ModuleItem {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for ModuleItem {
+    type Owned = TreeArc<ModuleItem>;
     fn to_owned(&self) -> TreeArc<ModuleItem> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1909,6 +2145,10 @@ impl AstNode for Name {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for Name {
+    type Owned = TreeArc<Name>;
     fn to_owned(&self) -> TreeArc<Name> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1933,6 +2173,10 @@ impl AstNode for NameRef {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for NameRef {
+    type Owned = TreeArc<NameRef>;
     fn to_owned(&self) -> TreeArc<NameRef> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1957,6 +2201,10 @@ impl AstNode for NamedField {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for NamedField {
+    type Owned = TreeArc<NamedField>;
     fn to_owned(&self) -> TreeArc<NamedField> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -1989,6 +2237,10 @@ impl AstNode for NamedFieldDef {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for NamedFieldDef {
+    type Owned = TreeArc<NamedFieldDef>;
     fn to_owned(&self) -> TreeArc<NamedFieldDef> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2020,6 +2272,10 @@ impl AstNode for NamedFieldDefList {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for NamedFieldDefList {
+    type Owned = TreeArc<NamedFieldDefList>;
     fn to_owned(&self) -> TreeArc<NamedFieldDefList> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2048,6 +2304,10 @@ impl AstNode for NamedFieldList {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for NamedFieldList {
+    type Owned = TreeArc<NamedFieldList>;
     fn to_owned(&self) -> TreeArc<NamedFieldList> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2076,6 +2336,10 @@ impl AstNode for NeverType {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for NeverType {
+    type Owned = TreeArc<NeverType>;
     fn to_owned(&self) -> TreeArc<NeverType> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2107,6 +2371,10 @@ impl AstNode for NominalDef {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for NominalDef {
+    type Owned = TreeArc<NominalDef>;
     fn to_owned(&self) -> TreeArc<NominalDef> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2143,6 +2411,10 @@ impl AstNode for Param {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for Param {
+    type Owned = TreeArc<Param>;
     fn to_owned(&self) -> TreeArc<Param> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2175,6 +2447,10 @@ impl AstNode for ParamList {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for ParamList {
+    type Owned = TreeArc<ParamList>;
     fn to_owned(&self) -> TreeArc<ParamList> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2207,6 +2483,10 @@ impl AstNode for ParenExpr {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for ParenExpr {
+    type Owned = TreeArc<ParenExpr>;
     fn to_owned(&self) -> TreeArc<ParenExpr> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2235,6 +2515,10 @@ impl AstNode for ParenType {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for ParenType {
+    type Owned = TreeArc<ParenType>;
     fn to_owned(&self) -> TreeArc<ParenType> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2284,6 +2568,10 @@ impl AstNode for Pat {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for Pat {
+    type Owned = TreeArc<Pat>;
     fn to_owned(&self) -> TreeArc<Pat> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2324,6 +2612,10 @@ impl AstNode for Path {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for Path {
+    type Owned = TreeArc<Path>;
     fn to_owned(&self) -> TreeArc<Path> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2356,6 +2648,10 @@ impl AstNode for PathExpr {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for PathExpr {
+    type Owned = TreeArc<PathExpr>;
     fn to_owned(&self) -> TreeArc<PathExpr> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2384,6 +2680,10 @@ impl AstNode for PathPat {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for PathPat {
+    type Owned = TreeArc<PathPat>;
     fn to_owned(&self) -> TreeArc<PathPat> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2412,6 +2712,10 @@ impl AstNode for PathSegment {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for PathSegment {
+    type Owned = TreeArc<PathSegment>;
     fn to_owned(&self) -> TreeArc<PathSegment> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2444,6 +2748,10 @@ impl AstNode for PathType {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for PathType {
+    type Owned = TreeArc<PathType>;
     fn to_owned(&self) -> TreeArc<PathType> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2472,6 +2780,10 @@ impl AstNode for PlaceholderPat {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for PlaceholderPat {
+    type Owned = TreeArc<PlaceholderPat>;
     fn to_owned(&self) -> TreeArc<PlaceholderPat> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2496,6 +2808,10 @@ impl AstNode for PlaceholderType {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for PlaceholderType {
+    type Owned = TreeArc<PlaceholderType>;
     fn to_owned(&self) -> TreeArc<PlaceholderType> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2520,6 +2836,10 @@ impl AstNode for PointerType {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for PointerType {
+    type Owned = TreeArc<PointerType>;
     fn to_owned(&self) -> TreeArc<PointerType> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2548,6 +2868,10 @@ impl AstNode for PosField {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for PosField {
+    type Owned = TreeArc<PosField>;
     fn to_owned(&self) -> TreeArc<PosField> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2578,6 +2902,10 @@ impl AstNode for PosFieldList {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for PosFieldList {
+    type Owned = TreeArc<PosFieldList>;
     fn to_owned(&self) -> TreeArc<PosFieldList> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2606,6 +2934,10 @@ impl AstNode for PrefixExpr {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for PrefixExpr {
+    type Owned = TreeArc<PrefixExpr>;
     fn to_owned(&self) -> TreeArc<PrefixExpr> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2634,6 +2966,10 @@ impl AstNode for RangeExpr {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for RangeExpr {
+    type Owned = TreeArc<RangeExpr>;
     fn to_owned(&self) -> TreeArc<RangeExpr> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2658,6 +2994,10 @@ impl AstNode for RangePat {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for RangePat {
+    type Owned = TreeArc<RangePat>;
     fn to_owned(&self) -> TreeArc<RangePat> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2682,6 +3022,10 @@ impl AstNode for RawByteString {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for RawByteString {
+    type Owned = TreeArc<RawByteString>;
     fn to_owned(&self) -> TreeArc<RawByteString> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2707,6 +3051,10 @@ impl AstNode for RawString {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for RawString {
+    type Owned = TreeArc<RawString>;
     fn to_owned(&self) -> TreeArc<RawString> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2732,6 +3080,10 @@ impl AstNode for RefExpr {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for RefExpr {
+    type Owned = TreeArc<RefExpr>;
     fn to_owned(&self) -> TreeArc<RefExpr> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2760,6 +3112,10 @@ impl AstNode for RefPat {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for RefPat {
+    type Owned = TreeArc<RefPat>;
     fn to_owned(&self) -> TreeArc<RefPat> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2788,6 +3144,10 @@ impl AstNode for ReferenceType {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for ReferenceType {
+    type Owned = TreeArc<ReferenceType>;
     fn to_owned(&self) -> TreeArc<ReferenceType> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2816,6 +3176,10 @@ impl AstNode for RetType {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for RetType {
+    type Owned = TreeArc<RetType>;
     fn to_owned(&self) -> TreeArc<RetType> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2844,6 +3208,10 @@ impl AstNode for ReturnExpr {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for ReturnExpr {
+    type Owned = TreeArc<ReturnExpr>;
     fn to_owned(&self) -> TreeArc<ReturnExpr> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2872,6 +3240,10 @@ impl AstNode for SelfKw {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for SelfKw {
+    type Owned = TreeArc<SelfKw>;
     fn to_owned(&self) -> TreeArc<SelfKw> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2896,6 +3268,10 @@ impl AstNode for SelfParam {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for SelfParam {
+    type Owned = TreeArc<SelfParam>;
     fn to_owned(&self) -> TreeArc<SelfParam> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2928,6 +3304,10 @@ impl AstNode for SlicePat {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for SlicePat {
+    type Owned = TreeArc<SlicePat>;
     fn to_owned(&self) -> TreeArc<SlicePat> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2952,6 +3332,10 @@ impl AstNode for SliceType {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for SliceType {
+    type Owned = TreeArc<SliceType>;
     fn to_owned(&self) -> TreeArc<SliceType> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -2980,6 +3364,10 @@ impl AstNode for SourceFile {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for SourceFile {
+    type Owned = TreeArc<SourceFile>;
     fn to_owned(&self) -> TreeArc<SourceFile> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -3010,6 +3398,10 @@ impl AstNode for StaticDef {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for StaticDef {
+    type Owned = TreeArc<StaticDef>;
     fn to_owned(&self) -> TreeArc<StaticDef> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -3050,6 +3442,10 @@ impl AstNode for Stmt {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for Stmt {
+    type Owned = TreeArc<Stmt>;
     fn to_owned(&self) -> TreeArc<Stmt> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -3083,6 +3479,10 @@ impl AstNode for String {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for String {
+    type Owned = TreeArc<String>;
     fn to_owned(&self) -> TreeArc<String> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -3108,6 +3508,10 @@ impl AstNode for StructDef {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for StructDef {
+    type Owned = TreeArc<StructDef>;
     fn to_owned(&self) -> TreeArc<StructDef> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -3137,6 +3541,10 @@ impl AstNode for StructLit {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for StructLit {
+    type Owned = TreeArc<StructLit>;
     fn to_owned(&self) -> TreeArc<StructLit> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -3173,6 +3581,10 @@ impl AstNode for StructPat {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for StructPat {
+    type Owned = TreeArc<StructPat>;
     fn to_owned(&self) -> TreeArc<StructPat> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -3205,6 +3617,10 @@ impl AstNode for TokenTree {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for TokenTree {
+    type Owned = TreeArc<TokenTree>;
     fn to_owned(&self) -> TreeArc<TokenTree> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -3229,6 +3645,10 @@ impl AstNode for TraitDef {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for TraitDef {
+    type Owned = TreeArc<TraitDef>;
     fn to_owned(&self) -> TreeArc<TraitDef> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -3237,6 +3657,7 @@ impl ast::VisibilityOwner for TraitDef {}
 impl ast::NameOwner for TraitDef {}
 impl ast::AttrsOwner for TraitDef {}
 impl ast::DocCommentsOwner for TraitDef {}
+impl ast::TypeParamsOwner for TraitDef {}
 impl TraitDef {}
 
 // TrueKw
@@ -3257,6 +3678,10 @@ impl AstNode for TrueKw {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for TrueKw {
+    type Owned = TreeArc<TrueKw>;
     fn to_owned(&self) -> TreeArc<TrueKw> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -3282,6 +3707,10 @@ impl AstNode for TryExpr {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for TryExpr {
+    type Owned = TreeArc<TryExpr>;
     fn to_owned(&self) -> TreeArc<TryExpr> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -3310,6 +3739,10 @@ impl AstNode for TupleExpr {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for TupleExpr {
+    type Owned = TreeArc<TupleExpr>;
     fn to_owned(&self) -> TreeArc<TupleExpr> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -3338,6 +3771,10 @@ impl AstNode for TuplePat {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for TuplePat {
+    type Owned = TreeArc<TuplePat>;
     fn to_owned(&self) -> TreeArc<TuplePat> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -3366,6 +3803,10 @@ impl AstNode for TupleStructPat {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for TupleStructPat {
+    type Owned = TreeArc<TupleStructPat>;
     fn to_owned(&self) -> TreeArc<TupleStructPat> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -3398,6 +3839,10 @@ impl AstNode for TupleType {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for TupleType {
+    type Owned = TreeArc<TupleType>;
     fn to_owned(&self) -> TreeArc<TupleType> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -3426,6 +3871,10 @@ impl AstNode for TypeArg {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for TypeArg {
+    type Owned = TreeArc<TypeArg>;
     fn to_owned(&self) -> TreeArc<TypeArg> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -3454,6 +3903,10 @@ impl AstNode for TypeArgList {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for TypeArgList {
+    type Owned = TreeArc<TypeArgList>;
     fn to_owned(&self) -> TreeArc<TypeArgList> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -3490,6 +3943,10 @@ impl AstNode for TypeDef {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for TypeDef {
+    type Owned = TreeArc<TypeDef>;
     fn to_owned(&self) -> TreeArc<TypeDef> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -3523,6 +3980,10 @@ impl AstNode for TypeParam {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for TypeParam {
+    type Owned = TreeArc<TypeParam>;
     fn to_owned(&self) -> TreeArc<TypeParam> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -3548,6 +4009,10 @@ impl AstNode for TypeParamList {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for TypeParamList {
+    type Owned = TreeArc<TypeParamList>;
     fn to_owned(&self) -> TreeArc<TypeParamList> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -3609,6 +4074,10 @@ impl AstNode for TypeRef {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for TypeRef {
+    type Owned = TreeArc<TypeRef>;
     fn to_owned(&self) -> TreeArc<TypeRef> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -3653,6 +4122,10 @@ impl AstNode for UseItem {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for UseItem {
+    type Owned = TreeArc<UseItem>;
     fn to_owned(&self) -> TreeArc<UseItem> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -3681,6 +4154,10 @@ impl AstNode for UseTree {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for UseTree {
+    type Owned = TreeArc<UseTree>;
     fn to_owned(&self) -> TreeArc<UseTree> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -3713,6 +4190,10 @@ impl AstNode for UseTreeList {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for UseTreeList {
+    type Owned = TreeArc<UseTreeList>;
     fn to_owned(&self) -> TreeArc<UseTreeList> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -3741,6 +4222,10 @@ impl AstNode for Visibility {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for Visibility {
+    type Owned = TreeArc<Visibility>;
     fn to_owned(&self) -> TreeArc<Visibility> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -3765,6 +4250,10 @@ impl AstNode for WhereClause {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for WhereClause {
+    type Owned = TreeArc<WhereClause>;
     fn to_owned(&self) -> TreeArc<WhereClause> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -3789,6 +4278,10 @@ impl AstNode for WhileExpr {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for WhileExpr {
+    type Owned = TreeArc<WhileExpr>;
     fn to_owned(&self) -> TreeArc<WhileExpr> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -3818,6 +4311,10 @@ impl AstNode for Whitespace {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for Whitespace {
+    type Owned = TreeArc<Whitespace>;
     fn to_owned(&self) -> TreeArc<Whitespace> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
diff --git a/crates/ra_syntax/src/ast/generated.rs.tera b/crates/ra_syntax/src/ast/generated.rs.tera
index bf9db4ee8..ea0fc35fd 100644
--- a/crates/ra_syntax/src/ast/generated.rs.tera
+++ b/crates/ra_syntax/src/ast/generated.rs.tera
@@ -48,6 +48,10 @@ impl AstNode for {{ node }} {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for {{ node }} {
+    type Owned = TreeArc<{{ node }}>;
     fn to_owned(&self) -> TreeArc<{{ node }}> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
@@ -79,6 +83,10 @@ impl AstNode for {{ node }} {
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for {{ node }} {
+    type Owned = TreeArc<{{ node }}>;
     fn to_owned(&self) -> TreeArc<{{ node }}> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
diff --git a/crates/ra_syntax/src/grammar.ron b/crates/ra_syntax/src/grammar.ron
index 9a6f990b6..cb5d6cde8 100644
--- a/crates/ra_syntax/src/grammar.ron
+++ b/crates/ra_syntax/src/grammar.ron
@@ -280,7 +280,7 @@ Grammar(
         ], options: [["variant_list", "EnumVariantList"]] ),
         "EnumVariantList": ( collections: [["variants", "EnumVariant"]] ),
         "EnumVariant": ( traits: ["NameOwner", "DocCommentsOwner"], options: ["Expr"] ),
-        "TraitDef": ( traits: ["VisibilityOwner", "NameOwner", "AttrsOwner", "DocCommentsOwner"] ),
+        "TraitDef": ( traits: ["VisibilityOwner", "NameOwner", "AttrsOwner", "DocCommentsOwner", "TypeParamsOwner"] ),
         "Module": (
             traits: ["VisibilityOwner", "NameOwner", "AttrsOwner", "DocCommentsOwner" ],
             options: [ "ItemList" ]
@@ -498,7 +498,7 @@ Grammar(
         ),
 
         "RefPat": ( options: [ "Pat" ]),
-        "BindPat": ( 
+        "BindPat": (
             options: [ "Pat" ],
             traits: ["NameOwner"]
         ),
diff --git a/crates/ra_syntax/src/grammar/expressions.rs b/crates/ra_syntax/src/grammar/expressions.rs
index 2236555e0..7ee32fa7c 100644
--- a/crates/ra_syntax/src/grammar/expressions.rs
+++ b/crates/ra_syntax/src/grammar/expressions.rs
@@ -305,6 +305,8 @@ fn postfix_expr(
 // fn foo() {
 //     let _ = f();
 //     let _ = f()(1)(1, 2,);
+//     let _ = f(<Foo>::func());
+//     f(<Foo as Trait>::func());
 // }
 fn call_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
     assert!(p.at(L_PAREN));
diff --git a/crates/ra_syntax/src/grammar/expressions/atom.rs b/crates/ra_syntax/src/grammar/expressions/atom.rs
index 167a76551..6d6d89f70 100644
--- a/crates/ra_syntax/src/grammar/expressions/atom.rs
+++ b/crates/ra_syntax/src/grammar/expressions/atom.rs
@@ -36,26 +36,22 @@ pub(crate) fn literal(p: &mut Parser) -> Option<CompletedMarker> {
 }
 
 // E.g. for after the break in `if break {}`, this should not match
-pub(super) const ATOM_EXPR_FIRST: TokenSet = LITERAL_FIRST.union(token_set![
-    L_PAREN,
-    L_CURLY,
-    L_BRACK,
-    PIPE,
-    MOVE_KW,
-    IF_KW,
-    WHILE_KW,
-    MATCH_KW,
-    UNSAFE_KW,
-    RETURN_KW,
-    IDENT,
-    SELF_KW,
-    SUPER_KW,
-    CRATE_KW,
-    COLONCOLON,
-    BREAK_KW,
-    CONTINUE_KW,
-    LIFETIME,
-]);
+pub(super) const ATOM_EXPR_FIRST: TokenSet =
+    LITERAL_FIRST.union(paths::PATH_FIRST).union(token_set![
+        L_PAREN,
+        L_CURLY,
+        L_BRACK,
+        PIPE,
+        MOVE_KW,
+        IF_KW,
+        WHILE_KW,
+        MATCH_KW,
+        UNSAFE_KW,
+        RETURN_KW,
+        BREAK_KW,
+        CONTINUE_KW,
+        LIFETIME,
+    ]);
 
 const EXPR_RECOVERY_SET: TokenSet = token_set![LET_KW];
 
diff --git a/crates/ra_syntax/src/yellow.rs b/crates/ra_syntax/src/yellow.rs
index a7bfb80e2..ed48739f8 100644
--- a/crates/ra_syntax/src/yellow.rs
+++ b/crates/ra_syntax/src/yellow.rs
@@ -2,10 +2,11 @@ mod builder;
 pub mod syntax_error;
 mod syntax_text;
 
+use std::{fmt, borrow::Borrow};
+
 use self::syntax_text::SyntaxText;
 use crate::{SmolStr, SyntaxKind, TextRange};
 use rowan::{Types, TransparentNewType};
-use std::fmt;
 
 pub(crate) use self::builder::GreenBuilder;
 pub use self::syntax_error::{SyntaxError, SyntaxErrorKind, Location};
@@ -25,6 +26,12 @@ pub struct TreeArc<T: TransparentNewType<Repr = rowan::SyntaxNode<RaTypes>>>(
     pub(crate) rowan::TreeArc<RaTypes, T>,
 );
 
+impl<T: TransparentNewType<Repr = rowan::SyntaxNode<RaTypes>>> Borrow<T> for TreeArc<T> {
+    fn borrow(&self) -> &T {
+        &*self
+    }
+}
+
 impl<T> TreeArc<T>
 where
     T: TransparentNewType<Repr = rowan::SyntaxNode<RaTypes>>,
@@ -124,6 +131,14 @@ impl SyntaxNode {
     }
 }
 
+impl ToOwned for SyntaxNode {
+    type Owned = TreeArc<SyntaxNode>;
+    fn to_owned(&self) -> TreeArc<SyntaxNode> {
+        let ptr = TreeArc(self.0.to_owned());
+        TreeArc::cast(ptr)
+    }
+}
+
 impl SyntaxNode {
     pub(crate) fn root_data(&self) -> &Vec<SyntaxError> {
         self.0.root_data()
@@ -133,11 +148,6 @@ impl SyntaxNode {
         self.0.replace_self(replacement)
     }
 
-    pub fn to_owned(&self) -> TreeArc<SyntaxNode> {
-        let ptr = TreeArc(self.0.to_owned());
-        TreeArc::cast(ptr)
-    }
-
     pub fn kind(&self) -> SyntaxKind {
         self.0.kind()
     }
diff --git a/crates/ra_syntax/tests/data/parser/inline/ok/0042_call_expr.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0042_call_expr.rs
index 0c9a20718..ffbf46d6d 100644
--- a/crates/ra_syntax/tests/data/parser/inline/ok/0042_call_expr.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0042_call_expr.rs
@@ -1,4 +1,6 @@
 fn foo() {
     let _ = f();
     let _ = f()(1)(1, 2,);
+    let _ = f(<Foo>::func());
+    f(<Foo as Trait>::func());
 }
diff --git a/crates/ra_syntax/tests/data/parser/inline/ok/0042_call_expr.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0042_call_expr.txt
index 6364dc73c..0ddf393f2 100644
--- a/crates/ra_syntax/tests/data/parser/inline/ok/0042_call_expr.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0042_call_expr.txt
@@ -1,5 +1,5 @@
-SOURCE_FILE@[0; 57)
-  FN_DEF@[0; 56)
+SOURCE_FILE@[0; 118)
+  FN_DEF@[0; 117)
     FN_KW@[0; 2)
     WHITESPACE@[2; 3)
     NAME@[3; 6)
@@ -8,7 +8,7 @@ SOURCE_FILE@[0; 57)
       L_PAREN@[6; 7)
       R_PAREN@[7; 8)
     WHITESPACE@[8; 9)
-    BLOCK@[9; 56)
+    BLOCK@[9; 117)
       L_CURLY@[9; 10)
       WHITESPACE@[10; 15)
       LET_STMT@[15; 27)
@@ -65,6 +65,83 @@ SOURCE_FILE@[0; 57)
             COMMA@[51; 52)
             R_PAREN@[52; 53)
         SEMI@[53; 54)
-      WHITESPACE@[54; 55)
-      R_CURLY@[55; 56)
-  WHITESPACE@[56; 57)
+      WHITESPACE@[54; 59)
+      LET_STMT@[59; 84)
+        LET_KW@[59; 62)
+        WHITESPACE@[62; 63)
+        PLACEHOLDER_PAT@[63; 64)
+          UNDERSCORE@[63; 64)
+        WHITESPACE@[64; 65)
+        EQ@[65; 66)
+        WHITESPACE@[66; 67)
+        CALL_EXPR@[67; 83)
+          PATH_EXPR@[67; 68)
+            PATH@[67; 68)
+              PATH_SEGMENT@[67; 68)
+                NAME_REF@[67; 68)
+                  IDENT@[67; 68) "f"
+          ARG_LIST@[68; 83)
+            L_PAREN@[68; 69)
+            CALL_EXPR@[69; 82)
+              PATH_EXPR@[69; 80)
+                PATH@[69; 80)
+                  PATH@[69; 74)
+                    PATH_SEGMENT@[69; 74)
+                      L_ANGLE@[69; 70)
+                      PATH_TYPE@[70; 73)
+                        PATH@[70; 73)
+                          PATH_SEGMENT@[70; 73)
+                            NAME_REF@[70; 73)
+                              IDENT@[70; 73) "Foo"
+                      R_ANGLE@[73; 74)
+                  COLONCOLON@[74; 76)
+                  PATH_SEGMENT@[76; 80)
+                    NAME_REF@[76; 80)
+                      IDENT@[76; 80) "func"
+              ARG_LIST@[80; 82)
+                L_PAREN@[80; 81)
+                R_PAREN@[81; 82)
+            R_PAREN@[82; 83)
+        SEMI@[83; 84)
+      WHITESPACE@[84; 89)
+      EXPR_STMT@[89; 115)
+        CALL_EXPR@[89; 114)
+          PATH_EXPR@[89; 90)
+            PATH@[89; 90)
+              PATH_SEGMENT@[89; 90)
+                NAME_REF@[89; 90)
+                  IDENT@[89; 90) "f"
+          ARG_LIST@[90; 114)
+            L_PAREN@[90; 91)
+            CALL_EXPR@[91; 113)
+              PATH_EXPR@[91; 111)
+                PATH@[91; 111)
+                  PATH@[91; 105)
+                    PATH_SEGMENT@[91; 105)
+                      L_ANGLE@[91; 92)
+                      PATH_TYPE@[92; 95)
+                        PATH@[92; 95)
+                          PATH_SEGMENT@[92; 95)
+                            NAME_REF@[92; 95)
+                              IDENT@[92; 95) "Foo"
+                      WHITESPACE@[95; 96)
+                      AS_KW@[96; 98)
+                      WHITESPACE@[98; 99)
+                      PATH_TYPE@[99; 104)
+                        PATH@[99; 104)
+                          PATH_SEGMENT@[99; 104)
+                            NAME_REF@[99; 104)
+                              IDENT@[99; 104) "Trait"
+                      R_ANGLE@[104; 105)
+                  COLONCOLON@[105; 107)
+                  PATH_SEGMENT@[107; 111)
+                    NAME_REF@[107; 111)
+                      IDENT@[107; 111) "func"
+              ARG_LIST@[111; 113)
+                L_PAREN@[111; 112)
+                R_PAREN@[112; 113)
+            R_PAREN@[113; 114)
+        SEMI@[114; 115)
+      WHITESPACE@[115; 116)
+      R_CURLY@[116; 117)
+  WHITESPACE@[117; 118)
diff --git a/crates/ra_syntax/tests/data/parser/ok/0042_ufcs_call_list.rs b/crates/ra_syntax/tests/data/parser/ok/0042_ufcs_call_list.rs
new file mode 100644
index 000000000..6c02e65ed
--- /dev/null
+++ b/crates/ra_syntax/tests/data/parser/ok/0042_ufcs_call_list.rs
@@ -0,0 +1,15 @@
+// https://github.com/rust-analyzer/rust-analyzer/issues/596
+
+struct Foo;
+
+impl Foo {
+    fn bar() -> bool {
+        unimplemented!()
+    }
+}
+
+fn baz(_: bool) {}
+
+fn main() {
+    baz(<Foo>::bar())
+}
diff --git a/crates/ra_syntax/tests/data/parser/ok/0042_ufcs_call_list.txt b/crates/ra_syntax/tests/data/parser/ok/0042_ufcs_call_list.txt
new file mode 100644
index 000000000..d1d890e50
--- /dev/null
+++ b/crates/ra_syntax/tests/data/parser/ok/0042_ufcs_call_list.txt
@@ -0,0 +1,123 @@
+SOURCE_FILE@[0; 199)
+  COMMENT@[0; 60)
+  WHITESPACE@[60; 62)
+  STRUCT_DEF@[62; 73)
+    STRUCT_KW@[62; 68)
+    WHITESPACE@[68; 69)
+    NAME@[69; 72)
+      IDENT@[69; 72) "Foo"
+    SEMI@[72; 73)
+  WHITESPACE@[73; 75)
+  IMPL_BLOCK@[75; 141)
+    IMPL_KW@[75; 79)
+    WHITESPACE@[79; 80)
+    PATH_TYPE@[80; 83)
+      PATH@[80; 83)
+        PATH_SEGMENT@[80; 83)
+          NAME_REF@[80; 83)
+            IDENT@[80; 83) "Foo"
+    WHITESPACE@[83; 84)
+    ITEM_LIST@[84; 141)
+      L_CURLY@[84; 85)
+      WHITESPACE@[85; 90)
+      FN_DEF@[90; 139)
+        FN_KW@[90; 92)
+        WHITESPACE@[92; 93)
+        NAME@[93; 96)
+          IDENT@[93; 96) "bar"
+        PARAM_LIST@[96; 98)
+          L_PAREN@[96; 97)
+          R_PAREN@[97; 98)
+        WHITESPACE@[98; 99)
+        RET_TYPE@[99; 106)
+          THIN_ARROW@[99; 101)
+          WHITESPACE@[101; 102)
+          PATH_TYPE@[102; 106)
+            PATH@[102; 106)
+              PATH_SEGMENT@[102; 106)
+                NAME_REF@[102; 106)
+                  IDENT@[102; 106) "bool"
+        WHITESPACE@[106; 107)
+        BLOCK@[107; 139)
+          L_CURLY@[107; 108)
+          WHITESPACE@[108; 117)
+          MACRO_CALL@[117; 133)
+            PATH@[117; 130)
+              PATH_SEGMENT@[117; 130)
+                NAME_REF@[117; 130)
+                  IDENT@[117; 130) "unimplemented"
+            EXCL@[130; 131)
+            TOKEN_TREE@[131; 133)
+              L_PAREN@[131; 132)
+              R_PAREN@[132; 133)
+          WHITESPACE@[133; 138)
+          R_CURLY@[138; 139)
+      WHITESPACE@[139; 140)
+      R_CURLY@[140; 141)
+  WHITESPACE@[141; 143)
+  FN_DEF@[143; 161)
+    FN_KW@[143; 145)
+    WHITESPACE@[145; 146)
+    NAME@[146; 149)
+      IDENT@[146; 149) "baz"
+    PARAM_LIST@[149; 158)
+      L_PAREN@[149; 150)
+      PARAM@[150; 157)
+        PLACEHOLDER_PAT@[150; 151)
+          UNDERSCORE@[150; 151)
+        COLON@[151; 152)
+        WHITESPACE@[152; 153)
+        PATH_TYPE@[153; 157)
+          PATH@[153; 157)
+            PATH_SEGMENT@[153; 157)
+              NAME_REF@[153; 157)
+                IDENT@[153; 157) "bool"
+      R_PAREN@[157; 158)
+    WHITESPACE@[158; 159)
+    BLOCK@[159; 161)
+      L_CURLY@[159; 160)
+      R_CURLY@[160; 161)
+  WHITESPACE@[161; 163)
+  FN_DEF@[163; 198)
+    FN_KW@[163; 165)
+    WHITESPACE@[165; 166)
+    NAME@[166; 170)
+      IDENT@[166; 170) "main"
+    PARAM_LIST@[170; 172)
+      L_PAREN@[170; 171)
+      R_PAREN@[171; 172)
+    WHITESPACE@[172; 173)
+    BLOCK@[173; 198)
+      L_CURLY@[173; 174)
+      WHITESPACE@[174; 179)
+      CALL_EXPR@[179; 196)
+        PATH_EXPR@[179; 182)
+          PATH@[179; 182)
+            PATH_SEGMENT@[179; 182)
+              NAME_REF@[179; 182)
+                IDENT@[179; 182) "baz"
+        ARG_LIST@[182; 196)
+          L_PAREN@[182; 183)
+          CALL_EXPR@[183; 195)
+            PATH_EXPR@[183; 193)
+              PATH@[183; 193)
+                PATH@[183; 188)
+                  PATH_SEGMENT@[183; 188)
+                    L_ANGLE@[183; 184)
+                    PATH_TYPE@[184; 187)
+                      PATH@[184; 187)
+                        PATH_SEGMENT@[184; 187)
+                          NAME_REF@[184; 187)
+                            IDENT@[184; 187) "Foo"
+                    R_ANGLE@[187; 188)
+                COLONCOLON@[188; 190)
+                PATH_SEGMENT@[190; 193)
+                  NAME_REF@[190; 193)
+                    IDENT@[190; 193) "bar"
+            ARG_LIST@[193; 195)
+              L_PAREN@[193; 194)
+              R_PAREN@[194; 195)
+          R_PAREN@[195; 196)
+      WHITESPACE@[196; 197)
+      R_CURLY@[197; 198)
+  WHITESPACE@[198; 199)