51 files changed, 2200 insertions, 1329 deletions
diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
index 307096ef3..d5c93f69b 100644
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -109,12 +109,7 @@ jobs:
        node-version: 12.x
    - name: Dist
-      if: github.ref == 'refs/heads/release'
+      run: cargo xtask dist --client-patch-version $GITHUB_RUN_NUMBER
-      run: cargo xtask dist --client 0.2.$GITHUB_RUN_NUMBER
-    - name: Dist
-      if: github.ref != 'refs/heads/release'
-      run: cargo xtask dist --nightly --client 0.3.$GITHUB_RUN_NUMBER-nightly
    - name: Run analysis-stats on rust-analyzer
      run: target/${{ env.RA_TARGET }}/release/rust-analyzer analysis-stats .
@@ -266,7 +261,7 @@ jobs:
      with:
        node-version: 12.x
-    - run: echo "TAG=$(date --iso --utc)" >> $GITHUB_ENV
+    - run: echo "TAG=$(date --iso -u)" >> $GITHUB_ENV
      if: github.ref == 'refs/heads/release'
    - run: echo "TAG=nightly" >> $GITHUB_ENV
      if: github.ref != 'refs/heads/release'
diff --git a/Cargo.lock b/Cargo.lock
index 907973412..ba6862e98 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -841,9 +841,9 @@ dependencies = [
 [[package]]
 name = "lsp-server"
-version = "0.5.0"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69b18dfe0e4a380b872aa79d8e0ee6c3d7a9682466e84b83ad807c88b3545f79"
+checksum = "6825d7042d5ca1825a366c40c9446928ec7b30e2be97243a13b164aee6583992"
 dependencies = [
 "crossbeam-channel",
 "log",
@@ -1303,9 +1303,9 @@ dependencies = [
 [[package]]
 name = "regex"
-version = "1.4.5"
+version = "1.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "957056ecddbeba1b26965114e191d2e8589ce74db242b6ea25fc4062427a5c19"
+checksum = "2a26af418b574bd56588335b3a3659a65725d4e636eb1016c2f9e3b38c7cc759"
 dependencies = [
 "regex-syntax",
 ]
@@ -1582,9 +1582,9 @@ dependencies = [
 [[package]]
 name = "syn"
-version = "1.0.69"
+version = "1.0.70"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48fe99c6bd8b1cc636890bcc071842de909d902c81ac7dab53ba33c421ab8ffb"
+checksum = "b9505f307c872bab8eb46f77ae357c8eba1fdacead58ee5a850116b1d7f82883"
 dependencies = [
 "proc-macro2",
 "quote",
diff --git a/crates/ide/src/display/navigation_target.rs b/crates/ide/src/display/navigation_target.rs
index 364be260c..2079c22a3 100644
--- a/crates/ide/src/display/navigation_target.rs
+++ b/crates/ide/src/display/navigation_target.rs
@@ -20,7 +20,7 @@ use syntax::{
 use crate::FileSymbol;
-/// `NavigationTarget` represents and element in the editor's UI which you can
+/// `NavigationTarget` represents an element in the editor's UI which you can
 /// click on to navigate to a particular piece of code.
 ///
 /// Typically, a `NavigationTarget` corresponds to some element in the source
@@ -35,12 +35,10 @@ pub struct NavigationTarget {
    /// Clients should use this range to answer "is the cursor inside the
    /// element?" question.
    pub full_range: TextRange,
-    /// A "most interesting" range withing the `full_range`.
+    /// A "most interesting" range within the `full_range`.
    ///
    /// Typically, `full_range` is the whole syntax node, including doc
-    /// comments, and `focus_range` is the range of the identifier. "Most
+    /// comments, and `focus_range` is the range of the identifier.
-    /// interesting" range within the full range, typically the range of
-    /// identifier.
    ///
    /// Clients should place the cursor on this range when navigating to this target.
    pub focus_range: Option<TextRange>,
diff --git a/crates/ide/src/references/rename.rs b/crates/ide/src/references/rename.rs
index 2408a0181..175e7a31d 100644
--- a/crates/ide/src/references/rename.rs
+++ b/crates/ide/src/references/rename.rs
@@ -50,6 +50,17 @@ pub(crate) fn prepare_rename(
    let sema = Semantics::new(db);
    let source_file = sema.parse(position.file_id);
    let syntax = source_file.syntax();
+    let def = find_definition(&sema, syntax, position)?;
+    match def {
+        Definition::SelfType(_) => bail!("Cannot rename `Self`"),
+        Definition::ModuleDef(ModuleDef::BuiltinType(_)) => bail!("Cannot rename builtin type"),
+        _ => {}
+    };
+    let nav =
+        def.try_to_nav(sema.db).ok_or_else(|| format_err!("No references found at position"))?;
+    nav.focus_range.ok_or_else(|| format_err!("No identifier available to rename"))?;
    let name_like = sema
        .find_node_at_offset_with_descend(&syntax, position.offset)
        .ok_or_else(|| format_err!("No references found at position"))?;
@@ -507,7 +518,8 @@ fn source_edit_from_def(
        def.try_to_nav(sema.db).ok_or_else(|| format_err!("No references found at position"))?;
    let mut replacement_text = String::new();
-    let mut repl_range = nav.focus_or_full_range();
+    let mut repl_range =
+        nav.focus_range.ok_or_else(|| format_err!("No identifier available to rename"))?;
    if let Definition::Local(local) = def {
        if let Either::Left(pat) = local.source(sema.db).value {
            if matches!(
@@ -626,6 +638,49 @@ foo!(Foo$0);",
    }
    #[test]
+    fn test_prepare_rename_tuple_field() {
+        check_prepare(
+            r#"
+struct Foo(i32);
+fn baz() {
+    let mut x = Foo(4);
+    x.0$0 = 5;
+}
+"#,
+            expect![[r#"No identifier available to rename"#]],
+        );
+    }
+    #[test]
+    fn test_prepare_rename_builtin() {
+        check_prepare(
+            r#"
+fn foo() {
+    let x: i32$0 = 0;
+}
+"#,
+            expect![[r#"Cannot rename builtin type"#]],
+        );
+    }
+    #[test]
+    fn test_prepare_rename_self() {
+        check_prepare(
+            r#"
+struct Foo {}
+impl Foo {
+    fn foo(self) -> Self$0 {
+        self
+    }
+}
+"#,
+            expect![[r#"Cannot rename `Self`"#]],
+        );
+    }
+    #[test]
    fn test_rename_to_underscore() {
        check("_", r#"fn main() { let i$0 = 1; }"#, r#"fn main() { let _ = 1; }"#);
    }
@@ -1787,4 +1842,50 @@ fn foo() {
 "#,
        )
    }
+    #[test]
+    fn test_rename_tuple_field() {
+        check(
+            "foo",
+            r#"
+struct Foo(i32);
+fn baz() {
+    let mut x = Foo(4);
+    x.0$0 = 5;
+}
+"#,
+            "error: No identifier available to rename",
+        );
+    }
+    #[test]
+    fn test_rename_builtin() {
+        check(
+            "foo",
+            r#"
+fn foo() {
+    let x: i32$0 = 0;
+}
+"#,
+            "error: Cannot rename builtin type",
+        );
+    }
+    #[test]
+    fn test_rename_self() {
+        check(
+            "foo",
+            r#"
+struct Foo {}
+impl Foo {
+    fn foo(self) -> Self$0 {
+        self
+    }
+}
+"#,
+            "error: Cannot rename `Self`",
+        );
+    }
 }
diff --git a/crates/ide/src/syntax_highlighting/highlight.rs b/crates/ide/src/syntax_highlighting/highlight.rs
index 18552459b..b586dcc17 100644
--- a/crates/ide/src/syntax_highlighting/highlight.rs
+++ b/crates/ide/src/syntax_highlighting/highlight.rs
@@ -1,6 +1,6 @@
 //! Computes color for a single element.
-use hir::{AsAssocItem, AssocItemContainer, Semantics, VariantDef};
+use hir::{AsAssocItem, Semantics};
 use ide_db::{
    defs::{Definition, NameClass, NameRefClass},
    RootDatabase, SymbolKind,
@@ -45,28 +45,26 @@ pub(super) fn element(
            };
            match name_kind {
-                Some(NameClass::ExternCrate(_)) => HlTag::Symbol(SymbolKind::Module).into(),
+                Some(NameClass::ExternCrate(_)) => SymbolKind::Module.into(),
                Some(NameClass::Definition(def)) => highlight_def(db, def) | HlMod::Definition,
                Some(NameClass::ConstReference(def)) => highlight_def(db, def),
                Some(NameClass::PatFieldShorthand { field_ref, .. }) => {
                    let mut h = HlTag::Symbol(SymbolKind::Field).into();
                    if let Definition::Field(field) = field_ref {
-                        if let VariantDef::Union(_) = field.parent_def(db) {
+                        if let hir::VariantDef::Union(_) = field.parent_def(db) {
                            h |= HlMod::Unsafe;
                        }
                    }
                    h
                }
                None => highlight_name_by_syntax(name) | HlMod::Definition,
            }
        }
        // Highlight references like the definitions they resolve to
        NAME_REF if element.ancestors().any(|it| it.kind() == ATTR) => {
            // even though we track whether we are in an attribute or not we still need this special case
            // as otherwise we would emit unresolved references for name refs inside attributes
-            Highlight::from(HlTag::Symbol(SymbolKind::Function))
+            SymbolKind::Function.into()
        }
        NAME_REF => {
            let name_ref = element.into_node().and_then(ast::NameRef::cast).unwrap();
@@ -74,7 +72,7 @@ pub(super) fn element(
                let is_self = name_ref.self_token().is_some();
                let h = match NameRefClass::classify(sema, &name_ref) {
                    Some(name_kind) => match name_kind {
-                        NameRefClass::ExternCrate(_) => HlTag::Symbol(SymbolKind::Module).into(),
+                        NameRefClass::ExternCrate(_) => SymbolKind::Module.into(),
                        NameRefClass::Definition(def) => {
                            if let Definition::Local(local) = &def {
                                if let Some(name) = local.name(db) {
@@ -95,7 +93,7 @@ pub(super) fn element(
                            if let Some(parent) = name_ref.syntax().parent() {
                                if matches!(parent.kind(), FIELD_EXPR | RECORD_PAT_FIELD) {
                                    if let Definition::Field(field) = def {
-                                        if let VariantDef::Union(_) = field.parent_def(db) {
+                                        if let hir::VariantDef::Union(_) = field.parent_def(db) {
                                            h |= HlMod::Unsafe;
                                        }
                                    }
@@ -104,9 +102,7 @@ pub(super) fn element(
                            h
                        }
-                        NameRefClass::FieldShorthand { .. } => {
+                        NameRefClass::FieldShorthand { .. } => SymbolKind::Field.into(),
-                            HlTag::Symbol(SymbolKind::Field).into()
-                        }
                    },
                    None if syntactic_name_ref_highlighting => {
                        highlight_name_ref_by_syntax(name_ref, sema)
@@ -114,7 +110,7 @@ pub(super) fn element(
                    None => HlTag::UnresolvedReference.into(),
                };
                if h.tag == HlTag::Symbol(SymbolKind::Module) && is_self {
-                    HlTag::Symbol(SymbolKind::SelfParam).into()
+                    SymbolKind::SelfParam.into()
                } else {
                    h
                }
@@ -135,7 +131,7 @@ pub(super) fn element(
        INT_NUMBER | FLOAT_NUMBER => HlTag::NumericLiteral.into(),
        BYTE => HlTag::ByteLiteral.into(),
        CHAR => HlTag::CharLiteral.into(),
-        QUESTION => Highlight::new(HlTag::Operator(HlOperator::Other)) | HlMod::ControlFlow,
+        QUESTION => HlTag::Operator(HlOperator::Other) | HlMod::ControlFlow,
        LIFETIME => {
            let lifetime = element.into_node().and_then(ast::Lifetime::cast).unwrap();
@@ -143,44 +139,31 @@ pub(super) fn element(
                Some(NameClass::Definition(def)) => highlight_def(db, def) | HlMod::Definition,
                None => match NameRefClass::classify_lifetime(sema, &lifetime) {
                    Some(NameRefClass::Definition(def)) => highlight_def(db, def),
-                    _ => Highlight::new(HlTag::Symbol(SymbolKind::LifetimeParam)),
+                    _ => SymbolKind::LifetimeParam.into(),
                },
-                _ => Highlight::new(HlTag::Symbol(SymbolKind::LifetimeParam)) | HlMod::Definition,
+                _ => Highlight::from(SymbolKind::LifetimeParam) | HlMod::Definition,
            }
        }
        p if p.is_punct() => match p {
-            T![&] if element.parent().and_then(ast::BinExpr::cast).is_some() => {
+            T![&] if parent_matches::<ast::BinExpr>(&element) => HlOperator::Bitwise.into(),
-                HlTag::Operator(HlOperator::Bitwise).into()
-            }
            T![&] => {
                let h = HlTag::Operator(HlOperator::Other).into();
                let is_unsafe = element
                    .parent()
                    .and_then(ast::RefExpr::cast)
-                    .map(|ref_expr| sema.is_unsafe_ref_expr(&ref_expr))
+                    .map_or(false, |ref_expr| sema.is_unsafe_ref_expr(&ref_expr));
-                    .unwrap_or(false);
                if is_unsafe {
                    h | HlMod::Unsafe
                } else {
                    h
                }
            }
-            T![::] | T![->] | T![=>] | T![..] | T![=] | T![@] | T![.] => {
+            T![::] | T![->] | T![=>] | T![..] | T![=] | T![@] | T![.] => HlOperator::Other.into(),
-                HlTag::Operator(HlOperator::Other).into()
+            T![!] if parent_matches::<ast::MacroCall>(&element) => SymbolKind::Macro.into(),
-            }
+            T![!] if parent_matches::<ast::NeverType>(&element) => HlTag::BuiltinType.into(),
-            T![!] if element.parent().and_then(ast::MacroCall::cast).is_some() => {
+            T![!] if parent_matches::<ast::PrefixExpr>(&element) => HlOperator::Logical.into(),
-                HlTag::Symbol(SymbolKind::Macro).into()
+            T![*] if parent_matches::<ast::PtrType>(&element) => HlTag::Keyword.into(),
-            }
+            T![*] if parent_matches::<ast::PrefixExpr>(&element) => {
-            T![!] if element.parent().and_then(ast::NeverType::cast).is_some() => {
-                HlTag::BuiltinType.into()
-            }
-            T![!] if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
-                HlTag::Operator(HlOperator::Logical).into()
-            }
-            T![*] if element.parent().and_then(ast::PtrType::cast).is_some() => {
-                HlTag::Keyword.into()
-            }
-            T![*] if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
                let prefix_expr = element.parent().and_then(ast::PrefixExpr::cast)?;
                let expr = prefix_expr.expr()?;
@@ -188,12 +171,12 @@ pub(super) fn element(
                if ty.is_raw_ptr() {
                    HlTag::Operator(HlOperator::Other) | HlMod::Unsafe
                } else if let Some(ast::PrefixOp::Deref) = prefix_expr.op_kind() {
-                    HlTag::Operator(HlOperator::Other).into()
+                    HlOperator::Other.into()
                } else {
-                    HlTag::Punctuation(HlPunct::Other).into()
+                    HlPunct::Other.into()
                }
            }
-            T![-] if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
+            T![-] if parent_matches::<ast::PrefixExpr>(&element) => {
                let prefix_expr = element.parent().and_then(ast::PrefixExpr::cast)?;
                let expr = prefix_expr.expr()?;
@@ -203,41 +186,31 @@ pub(super) fn element(
                }
                .into()
            }
-            _ if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
+            _ if parent_matches::<ast::PrefixExpr>(&element) => HlOperator::Other.into(),
-                HlTag::Operator(HlOperator::Other).into()
-            }
            T![+] | T![-] | T![*] | T![/] | T![+=] | T![-=] | T![*=] | T![/=]
-                if element.parent().and_then(ast::BinExpr::cast).is_some() =>
+                if parent_matches::<ast::BinExpr>(&element) =>
            {
-                HlTag::Operator(HlOperator::Arithmetic).into()
+                HlOperator::Arithmetic.into()
            }
            T![|] | T![&] | T![!] | T![^] | T![|=] | T![&=] | T![^=]
-                if element.parent().and_then(ast::BinExpr::cast).is_some() =>
+                if parent_matches::<ast::BinExpr>(&element) =>
            {
-                HlTag::Operator(HlOperator::Bitwise).into()
+                HlOperator::Bitwise.into()
            }
-            T![&&] | T![||] if element.parent().and_then(ast::BinExpr::cast).is_some() => {
+            T![&&] | T![||] if parent_matches::<ast::BinExpr>(&element) => {
-                HlTag::Operator(HlOperator::Logical).into()
+                HlOperator::Logical.into()
            }
            T![>] | T![<] | T![==] | T![>=] | T![<=] | T![!=]
-                if element.parent().and_then(ast::BinExpr::cast).is_some() =>
+                if parent_matches::<ast::BinExpr>(&element) =>
            {
-                HlTag::Operator(HlOperator::Comparison).into()
+                HlOperator::Comparison.into()
-            }
-            _ if element.parent().and_then(ast::BinExpr::cast).is_some() => {
-                HlTag::Operator(HlOperator::Other).into()
-            }
-            _ if element.parent().and_then(ast::RangeExpr::cast).is_some() => {
-                HlTag::Operator(HlOperator::Other).into()
            }
-            _ if element.parent().and_then(ast::RangePat::cast).is_some() => {
+            _ if parent_matches::<ast::BinExpr>(&element) => HlOperator::Other.into(),
-                HlTag::Operator(HlOperator::Other).into()
+            _ if parent_matches::<ast::RangeExpr>(&element) => HlOperator::Other.into(),
-            }
+            _ if parent_matches::<ast::RangePat>(&element) => HlOperator::Other.into(),
-            _ if element.parent().and_then(ast::RestPat::cast).is_some() => {
+            _ if parent_matches::<ast::RestPat>(&element) => HlOperator::Other.into(),
-                HlTag::Operator(HlOperator::Other).into()
+            _ if parent_matches::<ast::Attr>(&element) => HlTag::Attribute.into(),
-            }
+            kind => match kind {
-            _ if element.parent().and_then(ast::Attr::cast).is_some() => HlTag::Attribute.into(),
-            kind => HlTag::Punctuation(match kind {
                T!['['] | T![']'] => HlPunct::Bracket,
                T!['{'] | T!['}'] => HlPunct::Brace,
                T!['('] | T![')'] => HlPunct::Parenthesis,
@@ -247,22 +220,24 @@ pub(super) fn element(
                T![;] => HlPunct::Semi,
                T![.] => HlPunct::Dot,
                _ => HlPunct::Other,
-            })
+            }
            .into(),
        },
        k if k.is_keyword() => {
            let h = Highlight::new(HlTag::Keyword);
            match k {
-                T![break]
+                T![await]
+                | T![break]
                | T![continue]
                | T![else]
                | T![if]
+                | T![in]
                | T![loop]
                | T![match]
                | T![return]
                | T![while]
-                | T![in] => h | HlMod::ControlFlow,
+                | T![yield] => h | HlMod::ControlFlow,
                T![for] if !is_child_of_impl(&element) => h | HlMod::ControlFlow,
                T![unsafe] => h | HlMod::Unsafe,
                T![true] | T![false] => HlTag::BoolLiteral.into(),
@@ -301,7 +276,6 @@ pub(super) fn element(
        hash((name, shadow_count))
    }
 }
 fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
    match def {
        Definition::Macro(_) => HlTag::Symbol(SymbolKind::Macro),
@@ -312,17 +286,22 @@ fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
                let mut h = Highlight::new(HlTag::Symbol(SymbolKind::Function));
                if let Some(item) = func.as_assoc_item(db) {
                    h |= HlMod::Associated;
-                    if func.self_param(db).is_none() {
+                    match func.self_param(db) {
-                        h |= HlMod::Static
+                        Some(sp) => {
+                            if let hir::Access::Exclusive = sp.access(db) {
+                                h |= HlMod::Mutable;
+                            }
+                        }
+                        None => h |= HlMod::Static,
                    }
                    match item.container(db) {
-                        AssocItemContainer::Impl(i) => {
+                        hir::AssocItemContainer::Impl(i) => {
                            if i.trait_(db).is_some() {
                                h |= HlMod::Trait;
                            }
                        }
-                        AssocItemContainer::Trait(_t) => {
+                        hir::AssocItemContainer::Trait(_t) => {
                            h |= HlMod::Trait;
                        }
                    }
@@ -342,12 +321,12 @@ fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
                if let Some(item) = konst.as_assoc_item(db) {
                    h |= HlMod::Associated;
                    match item.container(db) {
-                        AssocItemContainer::Impl(i) => {
+                        hir::AssocItemContainer::Impl(i) => {
                            if i.trait_(db).is_some() {
                                h |= HlMod::Trait;
                            }
                        }
-                        AssocItemContainer::Trait(_t) => {
+                        hir::AssocItemContainer::Trait(_t) => {
                            h |= HlMod::Trait;
                        }
                    }
@@ -361,12 +340,12 @@ fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
                if let Some(item) = type_.as_assoc_item(db) {
                    h |= HlMod::Associated;
                    match item.container(db) {
-                        AssocItemContainer::Impl(i) => {
+                        hir::AssocItemContainer::Impl(i) => {
                            if i.trait_(db).is_some() {
                                h |= HlMod::Trait;
                            }
                        }
-                        AssocItemContainer::Trait(_t) => {
+                        hir::AssocItemContainer::Trait(_t) => {
                            h |= HlMod::Trait;
                        }
                    }
@@ -425,7 +404,7 @@ fn highlight_method_call(
    method_call: &ast::MethodCallExpr,
 ) -> Option<Highlight> {
    let func = sema.resolve_method_call(&method_call)?;
-    let mut h = HlTag::Symbol(SymbolKind::Function).into();
+    let mut h = SymbolKind::Function.into();
    h |= HlMod::Associated;
    if func.is_unsafe(sema.db) || sema.is_unsafe_method_call(&method_call) {
        h |= HlMod::Unsafe;
@@ -461,20 +440,20 @@ fn highlight_name_by_syntax(name: ast::Name) -> Highlight {
    };
    let tag = match parent.kind() {
-        STRUCT => HlTag::Symbol(SymbolKind::Struct),
+        STRUCT => SymbolKind::Struct,
-        ENUM => HlTag::Symbol(SymbolKind::Enum),
+        ENUM => SymbolKind::Enum,
-        VARIANT => HlTag::Symbol(SymbolKind::Variant),
+        VARIANT => SymbolKind::Variant,
-        UNION => HlTag::Symbol(SymbolKind::Union),
+        UNION => SymbolKind::Union,
-        TRAIT => HlTag::Symbol(SymbolKind::Trait),
+        TRAIT => SymbolKind::Trait,
-        TYPE_ALIAS => HlTag::Symbol(SymbolKind::TypeAlias),
+        TYPE_ALIAS => SymbolKind::TypeAlias,
-        TYPE_PARAM => HlTag::Symbol(SymbolKind::TypeParam),
+        TYPE_PARAM => SymbolKind::TypeParam,
-        RECORD_FIELD => HlTag::Symbol(SymbolKind::Field),
+        RECORD_FIELD => SymbolKind::Field,
-        MODULE => HlTag::Symbol(SymbolKind::Module),
+        MODULE => SymbolKind::Module,
-        FN => HlTag::Symbol(SymbolKind::Function),
+        FN => SymbolKind::Function,
-        CONST => HlTag::Symbol(SymbolKind::Const),
+        CONST => SymbolKind::Const,
-        STATIC => HlTag::Symbol(SymbolKind::Static),
+        STATIC => SymbolKind::Static,
-        IDENT_PAT => HlTag::Symbol(SymbolKind::Local),
+        IDENT_PAT => SymbolKind::Local,
-        _ => default,
+        _ => return default.into(),
    };
    tag.into()
@@ -492,20 +471,15 @@ fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics<RootDatabas
        METHOD_CALL_EXPR => {
            return ast::MethodCallExpr::cast(parent)
                .and_then(|it| highlight_method_call(sema, &it))
-                .unwrap_or_else(|| HlTag::Symbol(SymbolKind::Function).into());
+                .unwrap_or_else(|| SymbolKind::Function.into());
        }
        FIELD_EXPR => {
            let h = HlTag::Symbol(SymbolKind::Field);
            let is_union = ast::FieldExpr::cast(parent)
-                .and_then(|field_expr| {
+                .and_then(|field_expr| sema.resolve_field(&field_expr))
-                    let field = sema.resolve_field(&field_expr)?;
+                .map_or(false, |field| {
-                    Some(if let VariantDef::Union(_) = field.parent_def(sema.db) {
+                    matches!(field.parent_def(sema.db), hir::VariantDef::Union(_))
-                        true
+                });
-                    } else {
-                        false
-                    })
-                })
-                .unwrap_or(false);
            if is_union {
                h | HlMod::Unsafe
            } else {
@@ -522,9 +496,9 @@ fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics<RootDatabas
                _ => {
                    // within path, decide whether it is module or adt by checking for uppercase name
                    return if name.text().chars().next().unwrap_or_default().is_uppercase() {
-                        HlTag::Symbol(SymbolKind::Struct)
+                        SymbolKind::Struct
                    } else {
-                        HlTag::Symbol(SymbolKind::Module)
+                        SymbolKind::Module
                    }
                    .into();
                }
@@ -535,11 +509,11 @@ fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics<RootDatabas
            };
            match parent.kind() {
-                CALL_EXPR => HlTag::Symbol(SymbolKind::Function).into(),
+                CALL_EXPR => SymbolKind::Function.into(),
                _ => if name.text().chars().next().unwrap_or_default().is_uppercase() {
-                    HlTag::Symbol(SymbolKind::Struct)
+                    SymbolKind::Struct
                } else {
-                    HlTag::Symbol(SymbolKind::Const)
+                    SymbolKind::Const
                }
                .into(),
            }
@@ -574,6 +548,11 @@ fn parents_match(mut node: NodeOrToken<SyntaxNode, SyntaxToken>, mut kinds: &[Sy
    kinds.len() == 0
 }
+#[inline]
+fn parent_matches<N: AstNode>(element: &SyntaxElement) -> bool {
+    element.parent().map_or(false, |it| N::can_cast(it.kind()))
+}
 fn is_child_of_impl(element: &SyntaxElement) -> bool {
    match element.parent() {
        Some(e) => e.kind() == IMPL,
diff --git a/crates/ide/src/syntax_highlighting/tags.rs b/crates/ide/src/syntax_highlighting/tags.rs
index e58392d67..a304b3250 100644
--- a/crates/ide/src/syntax_highlighting/tags.rs
+++ b/crates/ide/src/syntax_highlighting/tags.rs
@@ -40,28 +40,33 @@ pub enum HlTag {
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
 #[repr(u8)]
 pub enum HlMod {
+    /// Used for items in traits and impls.
+    Associated = 0,
    /// Used to differentiate individual elements within attributes.
-    Attribute = 0,
+    Attribute,
+    /// Callable item or value.
+    Callable,
+    /// Value that is being consumed in a function call
+    Consuming,
    /// Used with keywords like `if` and `break`.
    ControlFlow,
    /// `foo` in `fn foo(x: i32)` is a definition, `foo` in `foo(90 + 2)` is
    /// not.
    Definition,
+    /// Doc-strings like this one.
    Documentation,
+    /// Highlighting injection like rust code in doc strings or ra_fixture.
    Injected,
-    Mutable,
-    Consuming,
-    Callable,
-    /// Used for associated functions
-    Static,
-    /// Used for items in impls&traits.
-    Associated,
    /// Used for intra doc links in doc injection.
    IntraDocLink,
+    /// Mutable binding.
+    Mutable,
+    /// Used for associated functions.
+    Static,
    /// Used for items in traits and trait impls.
    Trait,
+    // Keep this last!
-    /// Keep this last!
+    /// Used for unsafe functions, mutable statics, union accesses and unsafe operations.
    Unsafe,
 }
@@ -169,17 +174,17 @@ impl fmt::Display for HlTag {
 impl HlMod {
    const ALL: &'static [HlMod; HlMod::Unsafe as u8 as usize + 1] = &[
+        HlMod::Associated,
        HlMod::Attribute,
+        HlMod::Callable,
+        HlMod::Consuming,
        HlMod::ControlFlow,
        HlMod::Definition,
        HlMod::Documentation,
-        HlMod::IntraDocLink,
        HlMod::Injected,
+        HlMod::IntraDocLink,
        HlMod::Mutable,
-        HlMod::Consuming,
-        HlMod::Callable,
        HlMod::Static,
-        HlMod::Associated,
        HlMod::Trait,
        HlMod::Unsafe,
    ];
@@ -229,6 +234,24 @@ impl From<HlTag> for Highlight {
    }
 }
+impl From<HlOperator> for Highlight {
+    fn from(op: HlOperator) -> Highlight {
+        Highlight::new(HlTag::Operator(op))
+    }
+}
+impl From<HlPunct> for Highlight {
+    fn from(punct: HlPunct) -> Highlight {
+        Highlight::new(HlTag::Punctuation(punct))
+    }
+}
+impl From<SymbolKind> for Highlight {
+    fn from(sym: SymbolKind) -> Highlight {
+        Highlight::new(HlTag::Symbol(sym))
+    }
+}
 impl Highlight {
    pub(crate) fn new(tag: HlTag) -> Highlight {
        Highlight { tag, mods: HlMods::default() }
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html b/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html
index 8cde3906c..a0ea1db34 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html
@@ -42,17 +42,17 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="keyword">struct</span> <span class="struct declaration">foo</span> <span class="brace">{</span><span class="brace">}</span>
 <span class="keyword">impl</span> <span class="struct">foo</span> <span class="brace">{</span>
-    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration static associated">is_static</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
+    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function associated declaration static">is_static</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
-    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration associated">is_not_static</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
+    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function associated declaration">is_not_static</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
 <span class="brace">}</span>
 <span class="keyword">trait</span> <span class="trait declaration">t</span> <span class="brace">{</span>
-    <span class="keyword">fn</span> <span class="function declaration static associated trait">t_is_static</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
+    <span class="keyword">fn</span> <span class="function associated declaration static trait">t_is_static</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
-    <span class="keyword">fn</span> <span class="function declaration associated trait">t_is_not_static</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
+    <span class="keyword">fn</span> <span class="function associated declaration trait">t_is_not_static</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
 <span class="brace">}</span>
 <span class="keyword">impl</span> <span class="trait">t</span> <span class="keyword">for</span> <span class="struct">foo</span> <span class="brace">{</span>
-    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration static associated trait">is_static</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
+    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function associated declaration static trait">is_static</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
-    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration associated trait">is_not_static</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
+    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function associated declaration trait">is_not_static</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
 <span class="brace">}</span>
        </code></pre>
 \ No newline at end of file
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html b/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
index 6ee6d85fb..638f42c2f 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
@@ -50,7 +50,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="comment">//    KILLER WHALE</span>
    <span class="comment documentation">/// </span><span class="string_literal injected">    Ishmael."</span><span class="semicolon injected">;</span>
    <span class="comment documentation">/// ```</span>
-    <span class="keyword">pub</span> <span class="keyword">const</span> <span class="constant declaration associated">bar</span><span class="colon">:</span> <span class="builtin_type">bool</span> <span class="operator">=</span> <span class="bool_literal">true</span><span class="semicolon">;</span>
+    <span class="keyword">pub</span> <span class="keyword">const</span> <span class="constant associated declaration">bar</span><span class="colon">:</span> <span class="builtin_type">bool</span> <span class="operator">=</span> <span class="bool_literal">true</span><span class="semicolon">;</span>
    <span class="comment documentation">/// Constructs a new `Foo`.</span>
    <span class="comment documentation">///</span>
@@ -60,7 +60,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="comment documentation">/// #</span><span class="none injected"> </span><span class="attribute attribute injected">#</span><span class="attribute attribute injected">!</span><span class="attribute attribute injected">[</span><span class="function attribute injected">allow</span><span class="parenthesis attribute injected">(</span><span class="attribute attribute injected">unused_mut</span><span class="parenthesis attribute injected">)</span><span class="attribute attribute injected">]</span>
    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="none injected"> </span><span class="keyword injected">mut</span><span class="none injected"> </span><span class="variable declaration injected mutable">foo</span><span class="colon injected">:</span><span class="none injected"> </span><span class="struct injected">Foo</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="function injected">new</span><span class="parenthesis injected">(</span><span class="parenthesis injected">)</span><span class="semicolon injected">;</span>
    <span class="comment documentation">/// ```</span>
-    <span class="keyword">pub</span> <span class="keyword">const</span> <span class="keyword">fn</span> <span class="function declaration static associated">new</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="struct">Foo</span> <span class="brace">{</span>
+    <span class="keyword">pub</span> <span class="keyword">const</span> <span class="keyword">fn</span> <span class="function associated declaration static">new</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="struct">Foo</span> <span class="brace">{</span>
        <span class="struct">Foo</span> <span class="brace">{</span> <span class="field">bar</span><span class="colon">:</span> <span class="bool_literal">true</span> <span class="brace">}</span>
    <span class="brace">}</span>
@@ -94,15 +94,15 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="comment documentation">/// ```sh</span>
    <span class="comment documentation">/// echo 1</span>
    <span class="comment documentation">/// ```</span>
-    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration associated">foo</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">bool</span> <span class="brace">{</span>
+    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function associated declaration">foo</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">bool</span> <span class="brace">{</span>
        <span class="bool_literal">true</span>
    <span class="brace">}</span>
 <span class="brace">}</span>
-<span class="comment documentation">/// </span><span class="struct documentation intra_doc_link injected">[`Foo`](Foo)</span><span class="comment documentation"> is a struct</span>
+<span class="comment documentation">/// </span><span class="struct documentation injected intra_doc_link">[`Foo`](Foo)</span><span class="comment documentation"> is a struct</span>
-<span class="comment documentation">/// This function is &gt; </span><span class="function documentation intra_doc_link injected">[`all_the_links`](all_the_links)</span><span class="comment documentation"> &lt;</span>
+<span class="comment documentation">/// This function is &gt; </span><span class="function documentation injected intra_doc_link">[`all_the_links`](all_the_links)</span><span class="comment documentation"> &lt;</span>
 <span class="comment documentation">/// [`noop`](noop) is a macro below</span>
-<span class="comment documentation">/// </span><span class="struct documentation intra_doc_link injected">[`Item`]</span><span class="comment documentation"> is a struct in the module </span><span class="module documentation intra_doc_link injected">[`module`]</span>
+<span class="comment documentation">/// </span><span class="struct documentation injected intra_doc_link">[`Item`]</span><span class="comment documentation"> is a struct in the module </span><span class="module documentation injected intra_doc_link">[`module`]</span>
 <span class="comment documentation">///</span>
 <span class="comment documentation">/// [`Item`]: module::Item</span>
 <span class="comment documentation">/// [mix_and_match]: ThisShouldntResolve</span>
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html b/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html
index 7c6694a27..6202a03ce 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html
@@ -42,7 +42,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="keyword">fn</span> <span class="function declaration">main</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
    <span class="function">fixture</span><span class="parenthesis">(</span><span class="string_literal">r#"</span>
        <span class="keyword">trait</span> <span class="trait declaration">Foo</span> <span class="brace">{</span>
-            <span class="keyword">fn</span> <span class="function declaration static associated trait">foo</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
+            <span class="keyword">fn</span> <span class="function associated declaration static trait">foo</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
                <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"2 + 2 = {}"</span><span class="comma">,</span> <span class="numeric_literal">4</span><span class="parenthesis">)</span><span class="semicolon">;</span>
            <span class="brace">}</span>
        <span class="brace">}</span><span class="string_literal">"#</span>
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html b/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
index 72910421d..68165bdbf 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
@@ -47,7 +47,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="keyword">struct</span> <span class="struct declaration">HasUnsafeFn</span><span class="semicolon">;</span>
 <span class="keyword">impl</span> <span class="struct">HasUnsafeFn</span> <span class="brace">{</span>
-    <span class="keyword unsafe">unsafe</span> <span class="keyword">fn</span> <span class="function declaration associated unsafe">unsafe_method</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
+    <span class="keyword unsafe">unsafe</span> <span class="keyword">fn</span> <span class="function associated declaration unsafe">unsafe_method</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
 <span class="brace">}</span>
 <span class="keyword">struct</span> <span class="struct declaration">TypeForStaticMut</span> <span class="brace">{</span>
@@ -62,11 +62,11 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="brace">}</span>
 <span class="keyword">trait</span> <span class="trait declaration">DoTheAutoref</span> <span class="brace">{</span>
-    <span class="keyword">fn</span> <span class="function declaration associated trait">calls_autoref</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="keyword">fn</span> <span class="function associated declaration trait">calls_autoref</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span><span class="semicolon">;</span>
 <span class="brace">}</span>
 <span class="keyword">impl</span> <span class="trait">DoTheAutoref</span> <span class="keyword">for</span> <span class="builtin_type">u16</span> <span class="brace">{</span>
-    <span class="keyword">fn</span> <span class="function declaration associated trait">calls_autoref</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
+    <span class="keyword">fn</span> <span class="function associated declaration trait">calls_autoref</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
 <span class="brace">}</span>
 <span class="keyword">fn</span> <span class="function declaration">main</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlighting.html b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
index c43bcb691..df4192194 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlighting.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
@@ -67,25 +67,25 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="brace">}</span>
 <span class="keyword">trait</span> <span class="trait declaration">Bar</span> <span class="brace">{</span>
-    <span class="keyword">fn</span> <span class="function declaration associated trait">bar</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span><span class="semicolon">;</span>
+    <span class="keyword">fn</span> <span class="function associated declaration trait">bar</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span><span class="semicolon">;</span>
 <span class="brace">}</span>
 <span class="keyword">impl</span> <span class="trait">Bar</span> <span class="keyword">for</span> <span class="struct">Foo</span> <span class="brace">{</span>
-    <span class="keyword">fn</span> <span class="function declaration associated trait">bar</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span> <span class="brace">{</span>
+    <span class="keyword">fn</span> <span class="function associated declaration trait">bar</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span> <span class="brace">{</span>
        <span class="self_keyword">self</span><span class="operator">.</span><span class="field">x</span>
    <span class="brace">}</span>
 <span class="brace">}</span>
 <span class="keyword">impl</span> <span class="struct">Foo</span> <span class="brace">{</span>
-    <span class="keyword">fn</span> <span class="function declaration associated">baz</span><span class="parenthesis">(</span><span class="keyword">mut</span> <span class="self_keyword declaration mutable">self</span><span class="comma">,</span> <span class="value_param declaration">f</span><span class="colon">:</span> <span class="struct">Foo</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span> <span class="brace">{</span>
+    <span class="keyword">fn</span> <span class="function associated declaration">baz</span><span class="parenthesis">(</span><span class="keyword">mut</span> <span class="self_keyword declaration mutable">self</span><span class="comma">,</span> <span class="value_param declaration">f</span><span class="colon">:</span> <span class="struct">Foo</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span> <span class="brace">{</span>
-        <span class="value_param">f</span><span class="operator">.</span><span class="function consuming associated">baz</span><span class="parenthesis">(</span><span class="self_keyword mutable consuming">self</span><span class="parenthesis">)</span>
+        <span class="value_param">f</span><span class="operator">.</span><span class="function associated consuming">baz</span><span class="parenthesis">(</span><span class="self_keyword consuming mutable">self</span><span class="parenthesis">)</span>
    <span class="brace">}</span>
-    <span class="keyword">fn</span> <span class="function declaration associated">qux</span><span class="parenthesis">(</span><span class="operator">&</span><span class="keyword">mut</span> <span class="self_keyword declaration mutable">self</span><span class="parenthesis">)</span> <span class="brace">{</span>
+    <span class="keyword">fn</span> <span class="function associated declaration mutable">qux</span><span class="parenthesis">(</span><span class="operator">&</span><span class="keyword">mut</span> <span class="self_keyword declaration mutable">self</span><span class="parenthesis">)</span> <span class="brace">{</span>
        <span class="self_keyword mutable">self</span><span class="operator">.</span><span class="field">x</span> <span class="operator">=</span> <span class="numeric_literal">0</span><span class="semicolon">;</span>
    <span class="brace">}</span>
-    <span class="keyword">fn</span> <span class="function declaration associated">quop</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span> <span class="brace">{</span>
+    <span class="keyword">fn</span> <span class="function associated declaration">quop</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span> <span class="brace">{</span>
        <span class="self_keyword">self</span><span class="operator">.</span><span class="field">x</span>
    <span class="brace">}</span>
 <span class="brace">}</span>
@@ -96,15 +96,15 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="brace">}</span>
 <span class="keyword">impl</span> <span class="struct">FooCopy</span> <span class="brace">{</span>
-    <span class="keyword">fn</span> <span class="function declaration associated">baz</span><span class="parenthesis">(</span><span class="self_keyword declaration">self</span><span class="comma">,</span> <span class="value_param declaration">f</span><span class="colon">:</span> <span class="struct">FooCopy</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">u32</span> <span class="brace">{</span>
+    <span class="keyword">fn</span> <span class="function associated declaration">baz</span><span class="parenthesis">(</span><span class="self_keyword declaration">self</span><span class="comma">,</span> <span class="value_param declaration">f</span><span class="colon">:</span> <span class="struct">FooCopy</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">u32</span> <span class="brace">{</span>
        <span class="value_param">f</span><span class="operator">.</span><span class="function associated">baz</span><span class="parenthesis">(</span><span class="self_keyword">self</span><span class="parenthesis">)</span>
    <span class="brace">}</span>
-    <span class="keyword">fn</span> <span class="function declaration associated">qux</span><span class="parenthesis">(</span><span class="operator">&</span><span class="keyword">mut</span> <span class="self_keyword declaration mutable">self</span><span class="parenthesis">)</span> <span class="brace">{</span>
+    <span class="keyword">fn</span> <span class="function associated declaration mutable">qux</span><span class="parenthesis">(</span><span class="operator">&</span><span class="keyword">mut</span> <span class="self_keyword declaration mutable">self</span><span class="parenthesis">)</span> <span class="brace">{</span>
        <span class="self_keyword mutable">self</span><span class="operator">.</span><span class="field">x</span> <span class="operator">=</span> <span class="numeric_literal">0</span><span class="semicolon">;</span>
    <span class="brace">}</span>
-    <span class="keyword">fn</span> <span class="function declaration associated">quop</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">u32</span> <span class="brace">{</span>
+    <span class="keyword">fn</span> <span class="function associated declaration">quop</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">u32</span> <span class="brace">{</span>
        <span class="self_keyword">self</span><span class="operator">.</span><span class="field">x</span>
    <span class="brace">}</span>
 <span class="brace">}</span>
@@ -128,7 +128,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="brace">}</span>
 <span class="keyword">use</span> <span class="module">ops</span><span class="operator">::</span><span class="trait">Fn</span><span class="semicolon">;</span>
-<span class="keyword">fn</span> <span class="function declaration">baz</span><span class="angle">&lt;</span><span class="type_param declaration">F</span><span class="colon">:</span> <span class="trait">Fn</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="parenthesis">(</span><span class="parenthesis">)</span><span class="angle">&gt;</span><span class="parenthesis">(</span><span class="value_param declaration callable">f</span><span class="colon">:</span> <span class="type_param">F</span><span class="parenthesis">)</span> <span class="brace">{</span>
+<span class="keyword">fn</span> <span class="function declaration">baz</span><span class="angle">&lt;</span><span class="type_param declaration">F</span><span class="colon">:</span> <span class="trait">Fn</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="parenthesis">(</span><span class="parenthesis">)</span><span class="angle">&gt;</span><span class="parenthesis">(</span><span class="value_param callable declaration">f</span><span class="colon">:</span> <span class="type_param">F</span><span class="parenthesis">)</span> <span class="brace">{</span>
    <span class="value_param callable">f</span><span class="parenthesis">(</span><span class="parenthesis">)</span>
 <span class="brace">}</span>
@@ -199,16 +199,16 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">foo</span> <span class="operator">=</span> <span class="struct">Foo</span> <span class="brace">{</span> <span class="field">x</span><span class="comma">,</span> <span class="field">y</span><span class="colon">:</span> <span class="variable mutable">x</span> <span class="brace">}</span><span class="semicolon">;</span>
    <span class="keyword">let</span> <span class="variable declaration">foo2</span> <span class="operator">=</span> <span class="struct">Foo</span> <span class="brace">{</span> <span class="field">x</span><span class="comma">,</span> <span class="field">y</span><span class="colon">:</span> <span class="variable mutable">x</span> <span class="brace">}</span><span class="semicolon">;</span>
    <span class="variable mutable">foo</span><span class="operator">.</span><span class="function associated">quop</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
-    <span class="variable mutable">foo</span><span class="operator">.</span><span class="function mutable associated">qux</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="variable mutable">foo</span><span class="operator">.</span><span class="function associated mutable">qux</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
-    <span class="variable mutable">foo</span><span class="operator">.</span><span class="function consuming associated">baz</span><span class="parenthesis">(</span><span class="variable consuming">foo2</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="variable mutable">foo</span><span class="operator">.</span><span class="function associated consuming">baz</span><span class="parenthesis">(</span><span class="variable consuming">foo2</span><span class="parenthesis">)</span><span class="semicolon">;</span>
    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">copy</span> <span class="operator">=</span> <span class="struct">FooCopy</span> <span class="brace">{</span> <span class="field">x</span> <span class="brace">}</span><span class="semicolon">;</span>
    <span class="variable mutable">copy</span><span class="operator">.</span><span class="function associated">quop</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
-    <span class="variable mutable">copy</span><span class="operator">.</span><span class="function mutable associated">qux</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="variable mutable">copy</span><span class="operator">.</span><span class="function associated mutable">qux</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
    <span class="variable mutable">copy</span><span class="operator">.</span><span class="function associated">baz</span><span class="parenthesis">(</span><span class="variable mutable">copy</span><span class="parenthesis">)</span><span class="semicolon">;</span>
-    <span class="keyword">let</span> <span class="variable declaration callable">a</span> <span class="operator">=</span> <span class="punctuation">|</span><span class="value_param declaration">x</span><span class="punctuation">|</span> <span class="value_param">x</span><span class="semicolon">;</span>
+    <span class="keyword">let</span> <span class="variable callable declaration">a</span> <span class="operator">=</span> <span class="punctuation">|</span><span class="value_param declaration">x</span><span class="punctuation">|</span> <span class="value_param">x</span><span class="semicolon">;</span>
-    <span class="keyword">let</span> <span class="variable declaration callable">bar</span> <span class="operator">=</span> <span class="struct">Foo</span><span class="operator">::</span><span class="function associated">baz</span><span class="semicolon">;</span>
+    <span class="keyword">let</span> <span class="variable callable declaration">bar</span> <span class="operator">=</span> <span class="struct">Foo</span><span class="operator">::</span><span class="function associated">baz</span><span class="semicolon">;</span>
    <span class="keyword">let</span> <span class="variable declaration">baz</span> <span class="operator">=</span> <span class="numeric_literal">-</span><span class="numeric_literal">42</span><span class="semicolon">;</span>
    <span class="keyword">let</span> <span class="variable declaration">baz</span> <span class="operator">=</span> <span class="operator">-</span><span class="variable">baz</span><span class="semicolon">;</span>
@@ -228,7 +228,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="keyword">use</span> <span class="enum">Option</span><span class="operator">::</span><span class="punctuation">*</span><span class="semicolon">;</span>
 <span class="keyword">impl</span><span class="angle">&lt;</span><span class="type_param declaration">T</span><span class="angle">&gt;</span> <span class="enum">Option</span><span class="angle">&lt;</span><span class="type_param">T</span><span class="angle">&gt;</span> <span class="brace">{</span>
-    <span class="keyword">fn</span> <span class="function declaration associated">and</span><span class="angle">&lt;</span><span class="type_param declaration">U</span><span class="angle">&gt;</span><span class="parenthesis">(</span><span class="self_keyword declaration">self</span><span class="comma">,</span> <span class="value_param declaration">other</span><span class="colon">:</span> <span class="enum">Option</span><span class="angle">&lt;</span><span class="type_param">U</span><span class="angle">&gt;</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="enum">Option</span><span class="angle">&lt;</span><span class="parenthesis">(</span><span class="type_param">T</span><span class="comma">,</span> <span class="type_param">U</span><span class="parenthesis">)</span><span class="angle">&gt;</span> <span class="brace">{</span>
+    <span class="keyword">fn</span> <span class="function associated declaration">and</span><span class="angle">&lt;</span><span class="type_param declaration">U</span><span class="angle">&gt;</span><span class="parenthesis">(</span><span class="self_keyword declaration">self</span><span class="comma">,</span> <span class="value_param declaration">other</span><span class="colon">:</span> <span class="enum">Option</span><span class="angle">&lt;</span><span class="type_param">U</span><span class="angle">&gt;</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="enum">Option</span><span class="angle">&lt;</span><span class="parenthesis">(</span><span class="type_param">T</span><span class="comma">,</span> <span class="type_param">U</span><span class="parenthesis">)</span><span class="angle">&gt;</span> <span class="brace">{</span>
        <span class="keyword control">match</span> <span class="value_param">other</span> <span class="brace">{</span>
            <span class="enum_variant">None</span> <span class="operator">=&gt;</span> <span class="macro">unimplemented!</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="comma">,</span>
            <span class="variable declaration">Nope</span> <span class="operator">=&gt;</span> <span class="variable">Nope</span><span class="comma">,</span>
diff --git a/crates/ide_assists/src/ast_transform.rs b/crates/ide_assists/src/ast_transform.rs
index 4a3ed7783..e5ae718c9 100644
--- a/crates/ide_assists/src/ast_transform.rs
+++ b/crates/ide_assists/src/ast_transform.rs
@@ -3,20 +3,27 @@ use hir::{HirDisplay, PathResolution, SemanticsScope};
 use ide_db::helpers::mod_path_to_ast;
 use rustc_hash::FxHashMap;
 use syntax::{
-    algo::SyntaxRewriter,
    ast::{self, AstNode},
-    SyntaxNode,
+    ted, SyntaxNode,
 };
-pub fn apply<'a, N: AstNode>(transformer: &dyn AstTransform<'a>, node: N) -> N {
+pub fn apply<'a, N: AstNode>(transformer: &dyn AstTransform<'a>, node: &N) {
-    SyntaxRewriter::from_fn(|element| match element {
+    let mut skip_to = None;
-        syntax::SyntaxElement::Node(n) => {
+    for event in node.syntax().preorder() {
-            let replacement = transformer.get_substitution(&n, transformer)?;
+        match event {
-            Some(replacement.into())
+            syntax::WalkEvent::Enter(node) if skip_to.is_none() => {
+                skip_to = transformer.get_substitution(&node, transformer).zip(Some(node));
+            }
+            syntax::WalkEvent::Enter(_) => (),
+            syntax::WalkEvent::Leave(node) => match &skip_to {
+                Some((replacement, skip_target)) if *skip_target == node => {
+                    ted::replace(node, replacement.clone_for_update());
+                    skip_to.take();
+                }
+                _ => (),
+            },
        }
-        _ => None,
+    }
-    })
-    .rewrite_ast(&node)
 }
 /// `AstTransform` helps with applying bulk transformations to syntax nodes.
@@ -191,11 +198,9 @@ impl<'a> AstTransform<'a> for QualifyPaths<'a> {
                let found_path = from.find_use_path(self.source_scope.db.upcast(), def)?;
                let mut path = mod_path_to_ast(&found_path);
-                let type_args = p
+                let type_args = p.segment().and_then(|s| s.generic_arg_list());
-                    .segment()
-                    .and_then(|s| s.generic_arg_list())
-                    .map(|arg_list| apply(recur, arg_list));
                if let Some(type_args) = type_args {
+                    apply(recur, &type_args);
                    let last_segment = path.segment().unwrap();
                    path = path.with_segment(last_segment.with_generic_args(type_args))
                }
diff --git a/crates/ide_assists/src/handlers/auto_import.rs b/crates/ide_assists/src/handlers/auto_import.rs
index 49aa70f74..a454a2af3 100644
--- a/crates/ide_assists/src/handlers/auto_import.rs
+++ b/crates/ide_assists/src/handlers/auto_import.rs
@@ -93,7 +93,7 @@ pub(crate) fn auto_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
    let range = ctx.sema.original_range(&syntax_under_caret).range;
    let group_label = group_label(import_assets.import_candidate());
-    let scope = ImportScope::find_insert_use_container(&syntax_under_caret, &ctx.sema)?;
+    let scope = ImportScope::find_insert_use_container_with_macros(&syntax_under_caret, &ctx.sema)?;
    for import in proposed_imports {
        acc.add_group(
            &group_label,
@@ -101,9 +101,11 @@ pub(crate) fn auto_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
            format!("Import `{}`", import.import_path),
            range,
            |builder| {
-                let rewriter =
+                let scope = match scope.clone() {
-                    insert_use(&scope, mod_path_to_ast(&import.import_path), ctx.config.insert_use);
+                    ImportScope::File(it) => ImportScope::File(builder.make_ast_mut(it)),
-                builder.rewrite(rewriter);
+                    ImportScope::Module(it) => ImportScope::Module(builder.make_ast_mut(it)),
+                };
+                insert_use(&scope, mod_path_to_ast(&import.import_path), ctx.config.insert_use);
            },
        );
    }
diff --git a/crates/ide_assists/src/handlers/convert_tuple_struct_to_named_struct.rs b/crates/ide_assists/src/handlers/convert_tuple_struct_to_named_struct.rs
new file mode 100644
index 000000000..b5b5ada5e
--- /dev/null
+++ b/crates/ide_assists/src/handlers/convert_tuple_struct_to_named_struct.rs
@@ -0,0 +1,516 @@
+use ide_db::defs::{Definition, NameRefClass};
+use syntax::{
+    ast::{self, AstNode, GenericParamsOwner, VisibilityOwner},
+    match_ast, SyntaxNode,
+};
+use crate::{assist_context::AssistBuilder, AssistContext, AssistId, AssistKind, Assists};
+// Assist: convert_tuple_struct_to_named_struct
+//
+// Converts tuple struct to struct with named fields.
+//
+// ```
+// struct Point$0(f32, f32);
+//
+// impl Point {
+//     pub fn new(x: f32, y: f32) -> Self {
+//         Point(x, y)
+//     }
+//
+//     pub fn x(&self) -> f32 {
+//         self.0
+//     }
+//
+//     pub fn y(&self) -> f32 {
+//         self.1
+//     }
+// }
+// ```
+// ->
+// ```
+// struct Point { field1: f32, field2: f32 }
+//
+// impl Point {
+//     pub fn new(x: f32, y: f32) -> Self {
+//         Point { field1: x, field2: y }
+//     }
+//
+//     pub fn x(&self) -> f32 {
+//         self.field1
+//     }
+//
+//     pub fn y(&self) -> f32 {
+//         self.field2
+//     }
+// }
+// ```
+pub(crate) fn convert_tuple_struct_to_named_struct(
+    acc: &mut Assists,
+    ctx: &AssistContext,
+) -> Option<()> {
+    let strukt = ctx.find_node_at_offset::<ast::Struct>()?;
+    let tuple_fields = match strukt.field_list()? {
+        ast::FieldList::TupleFieldList(it) => it,
+        ast::FieldList::RecordFieldList(_) => return None,
+    };
+    let strukt_def = ctx.sema.to_def(&strukt)?;
+    let target = strukt.syntax().text_range();
+    acc.add(
+        AssistId("convert_tuple_struct_to_named_struct", AssistKind::RefactorRewrite),
+        "Convert to named struct",
+        target,
+        |edit| {
+            let names = generate_names(tuple_fields.fields());
+            edit_field_references(ctx, edit, tuple_fields.fields(), &names);
+            edit_struct_references(ctx, edit, strukt_def, &names);
+            edit_struct_def(ctx, edit, &strukt, tuple_fields, names);
+        },
+    )
+}
+fn edit_struct_def(
+    ctx: &AssistContext,
+    edit: &mut AssistBuilder,
+    strukt: &ast::Struct,
+    tuple_fields: ast::TupleFieldList,
+    names: Vec<ast::Name>,
+) {
+    let record_fields = tuple_fields
+        .fields()
+        .zip(names)
+        .filter_map(|(f, name)| Some(ast::make::record_field(f.visibility(), name, f.ty()?)));
+    let record_fields = ast::make::record_field_list(record_fields);
+    let tuple_fields_text_range = tuple_fields.syntax().text_range();
+    edit.edit_file(ctx.frange.file_id);
+    if let Some(w) = strukt.where_clause() {
+        edit.delete(w.syntax().text_range());
+        edit.insert(tuple_fields_text_range.start(), ast::make::tokens::single_newline().text());
+        edit.insert(tuple_fields_text_range.start(), w.syntax().text());
+        edit.insert(tuple_fields_text_range.start(), ",");
+        edit.insert(tuple_fields_text_range.start(), ast::make::tokens::single_newline().text());
+    } else {
+        edit.insert(tuple_fields_text_range.start(), ast::make::tokens::single_space().text());
+    }
+    edit.replace(tuple_fields_text_range, record_fields.to_string());
+    strukt.semicolon_token().map(|t| edit.delete(t.text_range()));
+}
+fn edit_struct_references(
+    ctx: &AssistContext,
+    edit: &mut AssistBuilder,
+    strukt: hir::Struct,
+    names: &[ast::Name],
+) {
+    let strukt_def = Definition::ModuleDef(hir::ModuleDef::Adt(hir::Adt::Struct(strukt)));
+    let usages = strukt_def.usages(&ctx.sema).include_self_kw_refs(true).all();
+    let edit_node = |edit: &mut AssistBuilder, node: SyntaxNode| -> Option<()> {
+        match_ast! {
+            match node {
+                ast::TupleStructPat(tuple_struct_pat) => {
+                    edit.replace(
+                        tuple_struct_pat.syntax().text_range(),
+                        ast::make::record_pat_with_fields(
+                            tuple_struct_pat.path()?,
+                            ast::make::record_pat_field_list(tuple_struct_pat.fields().zip(names).map(
+                                |(pat, name)| {
+                                    ast::make::record_pat_field(
+                                        ast::make::name_ref(&name.to_string()),
+                                        pat,
+                                    )
+                                },
+                            )),
+                        )
+                        .to_string(),
+                    );
+                },
+                // for tuple struct creations like Foo(42)
+                ast::CallExpr(call_expr) => {
+                    let path = call_expr.syntax().descendants().find_map(ast::PathExpr::cast).and_then(|expr| expr.path())?;
+                    // this also includes method calls like Foo::new(42), we should skip them
+                    if let Some(name_ref) = path.segment().and_then(|s| s.name_ref()) {
+                        match NameRefClass::classify(&ctx.sema, &name_ref) {
+                            Some(NameRefClass::Definition(Definition::SelfType(_))) => {},
+                            Some(NameRefClass::Definition(def)) if def == strukt_def => {},
+                            _ => return None,
+                        };
+                    }
+                    let arg_list = call_expr.syntax().descendants().find_map(ast::ArgList::cast)?;
+                    edit.replace(
+                        call_expr.syntax().text_range(),
+                        ast::make::record_expr(
+                            path,
+                            ast::make::record_expr_field_list(arg_list.args().zip(names).map(
+                                |(expr, name)| {
+                                    ast::make::record_expr_field(
+                                        ast::make::name_ref(&name.to_string()),
+                                        Some(expr),
+                                    )
+                                },
+                            )),
+                        )
+                        .to_string(),
+                    );
+                },
+                _ => return None,
+            }
+        }
+        Some(())
+    };
+    for (file_id, refs) in usages {
+        edit.edit_file(file_id);
+        for r in refs {
+            for node in r.name.syntax().ancestors() {
+                if edit_node(edit, node).is_some() {
+                    break;
+                }
+            }
+        }
+    }
+}
+fn edit_field_references(
+    ctx: &AssistContext,
+    edit: &mut AssistBuilder,
+    fields: impl Iterator<Item = ast::TupleField>,
+    names: &[ast::Name],
+) {
+    for (field, name) in fields.zip(names) {
+        let field = match ctx.sema.to_def(&field) {
+            Some(it) => it,
+            None => continue,
+        };
+        let def = Definition::Field(field);
+        let usages = def.usages(&ctx.sema).all();
+        for (file_id, refs) in usages {
+            edit.edit_file(file_id);
+            for r in refs {
+                if let Some(name_ref) = r.name.as_name_ref() {
+                    edit.replace(name_ref.syntax().text_range(), name.text());
+                }
+            }
+        }
+    }
+}
+fn generate_names(fields: impl Iterator<Item = ast::TupleField>) -> Vec<ast::Name> {
+    fields.enumerate().map(|(i, _)| ast::make::name(&format!("field{}", i + 1))).collect()
+}
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable};
+    use super::*;
+    #[test]
+    fn not_applicable_other_than_tuple_struct() {
+        check_assist_not_applicable(
+            convert_tuple_struct_to_named_struct,
+            r#"struct Foo$0 { bar: u32 };"#,
+        );
+        check_assist_not_applicable(convert_tuple_struct_to_named_struct, r#"struct Foo$0;"#);
+    }
+    #[test]
+    fn convert_simple_struct() {
+        check_assist(
+            convert_tuple_struct_to_named_struct,
+            r#"
+struct Inner;
+struct A$0(Inner);
+impl A {
+    fn new(inner: Inner) -> A {
+        A(inner)
+    }
+    fn new_with_default() -> A {
+        A::new(Inner)
+    }
+    fn into_inner(self) -> Inner {
+        self.0
+    }
+}"#,
+            r#"
+struct Inner;
+struct A { field1: Inner }
+impl A {
+    fn new(inner: Inner) -> A {
+        A { field1: inner }
+    }
+    fn new_with_default() -> A {
+        A::new(Inner)
+    }
+    fn into_inner(self) -> Inner {
+        self.field1
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn convert_struct_referenced_via_self_kw() {
+        check_assist(
+            convert_tuple_struct_to_named_struct,
+            r#"
+struct Inner;
+struct A$0(Inner);
+impl A {
+    fn new(inner: Inner) -> Self {
+        Self(inner)
+    }
+    fn new_with_default() -> Self {
+        Self::new(Inner)
+    }
+    fn into_inner(self) -> Inner {
+        self.0
+    }
+}"#,
+            r#"
+struct Inner;
+struct A { field1: Inner }
+impl A {
+    fn new(inner: Inner) -> Self {
+        Self { field1: inner }
+    }
+    fn new_with_default() -> Self {
+        Self::new(Inner)
+    }
+    fn into_inner(self) -> Inner {
+        self.field1
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn convert_destructured_struct() {
+        check_assist(
+            convert_tuple_struct_to_named_struct,
+            r#"
+struct Inner;
+struct A$0(Inner);
+impl A {
+    fn into_inner(self) -> Inner {
+        let A(first) = self;
+        first
+    }
+    fn into_inner_via_self(self) -> Inner {
+        let Self(first) = self;
+        first
+    }
+}"#,
+            r#"
+struct Inner;
+struct A { field1: Inner }
+impl A {
+    fn into_inner(self) -> Inner {
+        let A { field1: first } = self;
+        first
+    }
+    fn into_inner_via_self(self) -> Inner {
+        let Self { field1: first } = self;
+        first
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn convert_struct_with_visibility() {
+        check_assist(
+            convert_tuple_struct_to_named_struct,
+            r#"
+struct A$0(pub u32, pub(crate) u64);
+impl A {
+    fn new() -> A {
+        A(42, 42)
+    }
+    fn into_first(self) -> u32 {
+        self.0
+    }
+    fn into_second(self) -> u64 {
+        self.1
+    }
+}"#,
+            r#"
+struct A { pub field1: u32, pub(crate) field2: u64 }
+impl A {
+    fn new() -> A {
+        A { field1: 42, field2: 42 }
+    }
+    fn into_first(self) -> u32 {
+        self.field1
+    }
+    fn into_second(self) -> u64 {
+        self.field2
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn convert_struct_with_wrapped_references() {
+        check_assist(
+            convert_tuple_struct_to_named_struct,
+            r#"
+struct Inner$0(u32);
+struct Outer(Inner);
+impl Outer {
+    fn new() -> Self {
+        Self(Inner(42))
+    }
+    fn into_inner(self) -> u32 {
+        (self.0).0
+    }
+    fn into_inner_destructed(self) -> u32 {
+        let Outer(Inner(x)) = self;
+        x
+    }
+}"#,
+            r#"
+struct Inner { field1: u32 }
+struct Outer(Inner);
+impl Outer {
+    fn new() -> Self {
+        Self(Inner { field1: 42 })
+    }
+    fn into_inner(self) -> u32 {
+        (self.0).field1
+    }
+    fn into_inner_destructed(self) -> u32 {
+        let Outer(Inner { field1: x }) = self;
+        x
+    }
+}"#,
+        );
+        check_assist(
+            convert_tuple_struct_to_named_struct,
+            r#"
+struct Inner(u32);
+struct Outer$0(Inner);
+impl Outer {
+    fn new() -> Self {
+        Self(Inner(42))
+    }
+    fn into_inner(self) -> u32 {
+        (self.0).0
+    }
+    fn into_inner_destructed(self) -> u32 {
+        let Outer(Inner(x)) = self;
+        x
+    }
+}"#,
+            r#"
+struct Inner(u32);
+struct Outer { field1: Inner }
+impl Outer {
+    fn new() -> Self {
+        Self { field1: Inner(42) }
+    }
+    fn into_inner(self) -> u32 {
+        (self.field1).0
+    }
+    fn into_inner_destructed(self) -> u32 {
+        let Outer { field1: Inner(x) } = self;
+        x
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn convert_struct_with_multi_file_references() {
+        check_assist(
+            convert_tuple_struct_to_named_struct,
+            r#"
+//- /main.rs
+struct Inner;
+struct A$0(Inner);
+mod foo;
+//- /foo.rs
+use crate::{A, Inner};
+fn f() {
+    let a = A(Inner);
+}
+"#,
+            r#"
+//- /main.rs
+struct Inner;
+struct A { field1: Inner }
+mod foo;
+//- /foo.rs
+use crate::{A, Inner};
+fn f() {
+    let a = A { field1: Inner };
+}
+"#,
+        );
+    }
+    #[test]
+    fn convert_struct_with_where_clause() {
+        check_assist(
+            convert_tuple_struct_to_named_struct,
+            r#"
+struct Wrap$0<T>(T)
+where
+    T: Display;
+"#,
+            r#"
+struct Wrap<T>
+where
+    T: Display,
+{ field1: T }
+"#,
+        );
+    }
+}
diff --git a/crates/ide_assists/src/handlers/extract_struct_from_enum_variant.rs b/crates/ide_assists/src/handlers/extract_struct_from_enum_variant.rs
index a8d6355bd..66f274fa7 100644
--- a/crates/ide_assists/src/handlers/extract_struct_from_enum_variant.rs
+++ b/crates/ide_assists/src/handlers/extract_struct_from_enum_variant.rs
@@ -5,7 +5,7 @@ use hir::{Module, ModuleDef, Name, Variant};
 use ide_db::{
    defs::Definition,
    helpers::{
-        insert_use::{insert_use, ImportScope},
+        insert_use::{insert_use, ImportScope, InsertUseConfig},
        mod_path_to_ast,
    },
    search::FileReference,
@@ -13,9 +13,9 @@ use ide_db::{
 };
 use rustc_hash::FxHashSet;
 use syntax::{
-    algo::{find_node_at_offset, SyntaxRewriter},
+    algo::find_node_at_offset,
-    ast::{self, edit::IndentLevel, make, AstNode, NameOwner, VisibilityOwner},
+    ast::{self, make, AstNode, NameOwner, VisibilityOwner},
-    SourceFile, SyntaxElement, SyntaxNode, T,
+    ted, SyntaxNode, T,
 };
 use crate::{AssistContext, AssistId, AssistKind, Assists};
@@ -62,40 +62,50 @@ pub(crate) fn extract_struct_from_enum_variant(
            let mut visited_modules_set = FxHashSet::default();
            let current_module = enum_hir.module(ctx.db());
            visited_modules_set.insert(current_module);
-            let mut def_rewriter = None;
+            // record file references of the file the def resides in, we only want to swap to the edited file in the builder once
+            let mut def_file_references = None;
            for (file_id, references) in usages {
-                let mut rewriter = SyntaxRewriter::default();
-                let source_file = ctx.sema.parse(file_id);
-                for reference in references {
-                    update_reference(
-                        ctx,
-                        &mut rewriter,
-                        reference,
-                        &source_file,
-                        &enum_module_def,
-                        &variant_hir_name,
-                        &mut visited_modules_set,
-                    );
-                }
                if file_id == ctx.frange.file_id {
-                    def_rewriter = Some(rewriter);
+                    def_file_references = Some(references);
                    continue;
                }
                builder.edit_file(file_id);
-                builder.rewrite(rewriter);
+                let source_file = builder.make_ast_mut(ctx.sema.parse(file_id));
+                let processed = process_references(
+                    ctx,
+                    &mut visited_modules_set,
+                    source_file.syntax(),
+                    &enum_module_def,
+                    &variant_hir_name,
+                    references,
+                );
+                processed.into_iter().for_each(|(path, node, import)| {
+                    apply_references(ctx.config.insert_use, path, node, import)
+                });
            }
-            let mut rewriter = def_rewriter.unwrap_or_default();
-            update_variant(&mut rewriter, &variant);
-            extract_struct_def(
-                &mut rewriter,
-                &enum_ast,
-                variant_name.clone(),
-                &field_list,
-                &variant.parent_enum().syntax().clone().into(),
-                enum_ast.visibility(),
-            );
            builder.edit_file(ctx.frange.file_id);
-            builder.rewrite(rewriter);
+            let source_file = builder.make_ast_mut(ctx.sema.parse(ctx.frange.file_id));
+            let variant = builder.make_ast_mut(variant.clone());
+            if let Some(references) = def_file_references {
+                let processed = process_references(
+                    ctx,
+                    &mut visited_modules_set,
+                    source_file.syntax(),
+                    &enum_module_def,
+                    &variant_hir_name,
+                    references,
+                );
+                processed.into_iter().for_each(|(path, node, import)| {
+                    apply_references(ctx.config.insert_use, path, node, import)
+                });
+            }
+            let def = create_struct_def(variant_name.clone(), &field_list, enum_ast.visibility());
+            let start_offset = &variant.parent_enum().syntax().clone();
+            ted::insert_raw(ted::Position::before(start_offset), def.syntax());
+            ted::insert_raw(ted::Position::before(start_offset), &make::tokens::blank_line());
+            update_variant(&variant);
        },
    )
 }
@@ -136,34 +146,11 @@ fn existing_definition(db: &RootDatabase, variant_name: &ast::Name, variant: &Va
        .any(|(name, _)| name.to_string() == variant_name.to_string())
 }
-fn insert_import(
+fn create_struct_def(
-    ctx: &AssistContext,
-    rewriter: &mut SyntaxRewriter,
-    scope_node: &SyntaxNode,
-    module: &Module,
-    enum_module_def: &ModuleDef,
-    variant_hir_name: &Name,
-) -> Option<()> {
-    let db = ctx.db();
-    let mod_path =
-        module.find_use_path_prefixed(db, *enum_module_def, ctx.config.insert_use.prefix_kind);
-    if let Some(mut mod_path) = mod_path {
-        mod_path.pop_segment();
-        mod_path.push_segment(variant_hir_name.clone());
-        let scope = ImportScope::find_insert_use_container(scope_node, &ctx.sema)?;
-        *rewriter += insert_use(&scope, mod_path_to_ast(&mod_path), ctx.config.insert_use);
-    }
-    Some(())
-}
-fn extract_struct_def(
-    rewriter: &mut SyntaxRewriter,
-    enum_: &ast::Enum,
    variant_name: ast::Name,
    field_list: &Either<ast::RecordFieldList, ast::TupleFieldList>,
-    start_offset: &SyntaxElement,
    visibility: Option<ast::Visibility>,
-) -> Option<()> {
+) -> ast::Struct {
    let pub_vis = Some(make::visibility_pub());
    let field_list = match field_list {
        Either::Left(field_list) => {
@@ -180,65 +167,90 @@ fn extract_struct_def(
        .into(),
    };
-    rewriter.insert_before(
+    make::struct_(visibility, variant_name, None, field_list).clone_for_update()
-        start_offset,
-        make::struct_(visibility, variant_name, None, field_list).syntax(),
-    );
-    rewriter.insert_before(start_offset, &make::tokens::blank_line());
-    if let indent_level @ 1..=usize::MAX = IndentLevel::from_node(enum_.syntax()).0 as usize {
-        rewriter
-            .insert_before(start_offset, &make::tokens::whitespace(&" ".repeat(4 * indent_level)));
-    }
-    Some(())
 }
-fn update_variant(rewriter: &mut SyntaxRewriter, variant: &ast::Variant) -> Option<()> {
+fn update_variant(variant: &ast::Variant) -> Option<()> {
    let name = variant.name()?;
    let tuple_field = make::tuple_field(None, make::ty(&name.text()));
    let replacement = make::variant(
        name,
        Some(ast::FieldList::TupleFieldList(make::tuple_field_list(iter::once(tuple_field)))),
-    );
+    )
-    rewriter.replace(variant.syntax(), replacement.syntax());
+    .clone_for_update();
+    ted::replace(variant.syntax(), replacement.syntax());
    Some(())
 }
-fn update_reference(
+fn apply_references(
+    insert_use_cfg: InsertUseConfig,
+    segment: ast::PathSegment,
+    node: SyntaxNode,
+    import: Option<(ImportScope, hir::ModPath)>,
+) {
+    if let Some((scope, path)) = import {
+        insert_use(&scope, mod_path_to_ast(&path), insert_use_cfg);
+    }
+    ted::insert_raw(
+        ted::Position::before(segment.syntax()),
+        make::path_from_text(&format!("{}", segment)).clone_for_update().syntax(),
+    );
+    ted::insert_raw(ted::Position::before(segment.syntax()), make::token(T!['(']));
+    ted::insert_raw(ted::Position::after(&node), make::token(T![')']));
+}
+fn process_references(
    ctx: &AssistContext,
-    rewriter: &mut SyntaxRewriter,
+    visited_modules: &mut FxHashSet<Module>,
-    reference: FileReference,
+    source_file: &SyntaxNode,
-    source_file: &SourceFile,
    enum_module_def: &ModuleDef,
    variant_hir_name: &Name,
-    visited_modules_set: &mut FxHashSet<Module>,
+    refs: Vec<FileReference>,
-) -> Option<()> {
+) -> Vec<(ast::PathSegment, SyntaxNode, Option<(ImportScope, hir::ModPath)>)> {
+    // we have to recollect here eagerly as we are about to edit the tree we need to calculate the changes
+    // and corresponding nodes up front
+    refs.into_iter()
+        .flat_map(|reference| {
+            let (segment, scope_node, module) =
+                reference_to_node(&ctx.sema, source_file, reference)?;
+            if !visited_modules.contains(&module) {
+                let mod_path = module.find_use_path_prefixed(
+                    ctx.sema.db,
+                    *enum_module_def,
+                    ctx.config.insert_use.prefix_kind,
+                );
+                if let Some(mut mod_path) = mod_path {
+                    mod_path.pop_segment();
+                    mod_path.push_segment(variant_hir_name.clone());
+                    let scope = ImportScope::find_insert_use_container(&scope_node)?;
+                    visited_modules.insert(module);
+                    return Some((segment, scope_node, Some((scope, mod_path))));
+                }
+            }
+            Some((segment, scope_node, None))
+        })
+        .collect()
+}
+fn reference_to_node(
+    sema: &hir::Semantics<RootDatabase>,
+    source_file: &SyntaxNode,
+    reference: FileReference,
+) -> Option<(ast::PathSegment, SyntaxNode, hir::Module)> {
    let offset = reference.range.start();
-    let (segment, expr) = if let Some(path_expr) =
+    if let Some(path_expr) = find_node_at_offset::<ast::PathExpr>(source_file, offset) {
-        find_node_at_offset::<ast::PathExpr>(source_file.syntax(), offset)
-    {
        // tuple variant
-        (path_expr.path()?.segment()?, path_expr.syntax().parent()?)
+        Some((path_expr.path()?.segment()?, path_expr.syntax().parent()?))
-    } else if let Some(record_expr) =
+    } else if let Some(record_expr) = find_node_at_offset::<ast::RecordExpr>(source_file, offset) {
-        find_node_at_offset::<ast::RecordExpr>(source_file.syntax(), offset)
-    {
        // record variant
-        (record_expr.path()?.segment()?, record_expr.syntax().clone())
+        Some((record_expr.path()?.segment()?, record_expr.syntax().clone()))
    } else {
-        return None;
+        None
-    };
-    let module = ctx.sema.scope(&expr).module()?;
-    if !visited_modules_set.contains(&module) {
-        if insert_import(ctx, rewriter, &expr, &module, enum_module_def, variant_hir_name).is_some()
-        {
-            visited_modules_set.insert(module);
-        }
    }
-    rewriter.insert_after(segment.syntax(), &make::token(T!['(']));
+    .and_then(|(segment, expr)| {
-    rewriter.insert_after(segment.syntax(), segment.syntax());
+        let module = sema.scope(&expr).module()?;
-    rewriter.insert_after(&expr, &make::token(T![')']));
+        Some((segment, expr, module))
-    Some(())
+    })
 }
 #[cfg(test)]
@@ -345,7 +357,7 @@ mod my_mod {
        pub struct MyField(pub u8, pub u8);
-        pub enum MyEnum {
+pub enum MyEnum {
            MyField(MyField),
        }
    }
diff --git a/crates/ide_assists/src/handlers/merge_imports.rs b/crates/ide_assists/src/handlers/merge_imports.rs
index 8e0794218..add7b8e37 100644
--- a/crates/ide_assists/src/handlers/merge_imports.rs
+++ b/crates/ide_assists/src/handlers/merge_imports.rs
@@ -1,4 +1,4 @@
-use ide_db::helpers::insert_use::{try_merge_imports, try_merge_trees, MergeBehavior};
+use ide_db::helpers::merge_imports::{try_merge_imports, try_merge_trees, MergeBehavior};
 use syntax::{algo::neighbor, ast, ted, AstNode};
 use crate::{
diff --git a/crates/ide_assists/src/handlers/reorder_fields.rs b/crates/ide_assists/src/handlers/reorder_fields.rs
index 1a95135ca..e90bbdbcf 100644
--- a/crates/ide_assists/src/handlers/reorder_fields.rs
+++ b/crates/ide_assists/src/handlers/reorder_fields.rs
@@ -83,11 +83,9 @@ fn replace<T: AstNode + PartialEq>(
    fields: impl Iterator<Item = T>,
    sorted_fields: impl IntoIterator<Item = T>,
 ) {
-    fields.zip(sorted_fields).filter(|(field, sorted)| field != sorted).for_each(
+    fields.zip(sorted_fields).for_each(|(field, sorted_field)| {
-        |(field, sorted_field)| {
+        ted::replace(field.syntax(), sorted_field.syntax().clone_for_update())
-            ted::replace(field.syntax(), sorted_field.syntax().clone_for_update());
+    });
-        },
-    );
 }
 fn compute_fields_ranks(path: &ast::Path, ctx: &AssistContext) -> Option<FxHashMap<String, usize>> {
diff --git a/crates/ide_assists/src/handlers/reorder_impl.rs b/crates/ide_assists/src/handlers/reorder_impl.rs
index f976e73ad..72d889248 100644
--- a/crates/ide_assists/src/handlers/reorder_impl.rs
+++ b/crates/ide_assists/src/handlers/reorder_impl.rs
@@ -4,9 +4,8 @@ use rustc_hash::FxHashMap;
 use hir::{PathResolution, Semantics};
 use ide_db::RootDatabase;
 use syntax::{
-    algo,
    ast::{self, NameOwner},
-    AstNode,
+    ted, AstNode,
 };
 use crate::{AssistContext, AssistId, AssistKind, Assists};
@@ -75,13 +74,16 @@ pub(crate) fn reorder_impl(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
    }
    let target = items.syntax().text_range();
-    acc.add(AssistId("reorder_impl", AssistKind::RefactorRewrite), "Sort methods", target, |edit| {
+    acc.add(
-        let mut rewriter = algo::SyntaxRewriter::default();
+        AssistId("reorder_impl", AssistKind::RefactorRewrite),
-        for (old, new) in methods.iter().zip(&sorted) {
+        "Sort methods",
-            rewriter.replace(old.syntax(), new.syntax());
+        target,
-        }
+        |builder| {
-        edit.rewrite(rewriter);
+            methods.into_iter().zip(sorted).for_each(|(old, new)| {
-    })
+                ted::replace(builder.make_ast_mut(old).syntax(), new.clone_for_update().syntax())
+            });
+        },
+    )
 }
 fn compute_method_ranks(path: &ast::Path, ctx: &AssistContext) -> Option<FxHashMap<String, usize>> {
diff --git a/crates/ide_assists/src/handlers/replace_qualified_name_with_use.rs b/crates/ide_assists/src/handlers/replace_qualified_name_with_use.rs
index 36d2e0331..99ba79860 100644
--- a/crates/ide_assists/src/handlers/replace_qualified_name_with_use.rs
+++ b/crates/ide_assists/src/handlers/replace_qualified_name_with_use.rs
@@ -1,5 +1,5 @@
 use ide_db::helpers::insert_use::{insert_use, ImportScope};
-use syntax::{algo::SyntaxRewriter, ast, match_ast, AstNode, SyntaxNode};
+use syntax::{ast, match_ast, ted, AstNode, SyntaxNode};
 use crate::{AssistContext, AssistId, AssistKind, Assists};
@@ -31,7 +31,7 @@ pub(crate) fn replace_qualified_name_with_use(
    }
    let target = path.syntax().text_range();
-    let scope = ImportScope::find_insert_use_container(path.syntax(), &ctx.sema)?;
+    let scope = ImportScope::find_insert_use_container_with_macros(path.syntax(), &ctx.sema)?;
    let syntax = scope.as_syntax_node();
    acc.add(
        AssistId("replace_qualified_name_with_use", AssistKind::RefactorRewrite),
@@ -40,18 +40,17 @@ pub(crate) fn replace_qualified_name_with_use(
        |builder| {
            // Now that we've brought the name into scope, re-qualify all paths that could be
            // affected (that is, all paths inside the node we added the `use` to).
-            let mut rewriter = SyntaxRewriter::default();
+            let syntax = builder.make_mut(syntax.clone());
-            shorten_paths(&mut rewriter, syntax.clone(), &path);
            if let Some(ref import_scope) = ImportScope::from(syntax.clone()) {
-                rewriter += insert_use(import_scope, path, ctx.config.insert_use);
+                shorten_paths(&syntax, &path.clone_for_update());
-                builder.rewrite(rewriter);
+                insert_use(import_scope, path, ctx.config.insert_use);
            }
        },
    )
 }
 /// Adds replacements to `re` that shorten `path` in all descendants of `node`.
-fn shorten_paths(rewriter: &mut SyntaxRewriter<'static>, node: SyntaxNode, path: &ast::Path) {
+fn shorten_paths(node: &SyntaxNode, path: &ast::Path) {
    for child in node.children() {
        match_ast! {
            match child {
@@ -60,34 +59,26 @@ fn shorten_paths(rewriter: &mut SyntaxRewriter<'static>, node: SyntaxNode, path:
                ast::Use(_it) => continue,
                // Don't descend into submodules, they don't have the same `use` items in scope.
                ast::Module(_it) => continue,
+                ast::Path(p) => if maybe_replace_path(p.clone(), path.clone()).is_none() {
-                ast::Path(p) => {
+                    shorten_paths(p.syntax(), path);
-                    match maybe_replace_path(rewriter, p.clone(), path.clone()) {
-                        Some(()) => {},
-                        None => shorten_paths(rewriter, p.syntax().clone(), path),
-                    }
                },
-                _ => shorten_paths(rewriter, child, path),
+                _ => shorten_paths(&child, path),
            }
        }
    }
 }
-fn maybe_replace_path(
+fn maybe_replace_path(path: ast::Path, target: ast::Path) -> Option<()> {
-    rewriter: &mut SyntaxRewriter<'static>,
-    path: ast::Path,
-    target: ast::Path,
-) -> Option<()> {
    if !path_eq(path.clone(), target) {
        return None;
    }
    // Shorten `path`, leaving only its last segment.
    if let Some(parent) = path.qualifier() {
-        rewriter.delete(parent.syntax());
+        ted::remove(parent.syntax());
    }
    if let Some(double_colon) = path.coloncolon_token() {
-        rewriter.delete(&double_colon);
+        ted::remove(&double_colon);
    }
    Some(())
@@ -150,6 +141,7 @@ Debug
    ",
        );
    }
    #[test]
    fn test_replace_add_use_no_anchor_with_item_below() {
        check_assist(
diff --git a/crates/ide_assists/src/lib.rs b/crates/ide_assists/src/lib.rs
index 8996c1b61..88ae5c9a9 100644
--- a/crates/ide_assists/src/lib.rs
+++ b/crates/ide_assists/src/lib.rs
@@ -120,6 +120,7 @@ mod handlers {
    mod convert_comment_block;
    mod convert_iter_for_each_to_for;
    mod convert_into_to_from;
+    mod convert_tuple_struct_to_named_struct;
    mod early_return;
    mod expand_glob_import;
    mod extract_function;
@@ -190,6 +191,7 @@ mod handlers {
            convert_comment_block::convert_comment_block,
            convert_iter_for_each_to_for::convert_iter_for_each_to_for,
            convert_into_to_from::convert_into_to_from,
+            convert_tuple_struct_to_named_struct::convert_tuple_struct_to_named_struct,
            early_return::convert_to_guarded_return,
            expand_glob_import::expand_glob_import,
            extract_struct_from_enum_variant::extract_struct_from_enum_variant,
diff --git a/crates/ide_assists/src/tests.rs b/crates/ide_assists/src/tests.rs
index 49533e7d2..6f4f97361 100644
--- a/crates/ide_assists/src/tests.rs
+++ b/crates/ide_assists/src/tests.rs
@@ -4,10 +4,7 @@ use expect_test::expect;
 use hir::Semantics;
 use ide_db::{
    base_db::{fixture::WithFixture, FileId, FileRange, SourceDatabaseExt},
-    helpers::{
+    helpers::{insert_use::InsertUseConfig, merge_imports::MergeBehavior, SnippetCap},
-        insert_use::{InsertUseConfig, MergeBehavior},
-        SnippetCap,
-    },
    source_change::FileSystemEdit,
    RootDatabase,
 };
diff --git a/crates/ide_assists/src/tests/generated.rs b/crates/ide_assists/src/tests/generated.rs
index 41559b43a..59bcef8fb 100644
--- a/crates/ide_assists/src/tests/generated.rs
+++ b/crates/ide_assists/src/tests/generated.rs
@@ -292,6 +292,47 @@ fn main() {
 }
 #[test]
+fn doctest_convert_tuple_struct_to_named_struct() {
+    check_doc_test(
+        "convert_tuple_struct_to_named_struct",
+        r#####"
+struct Point$0(f32, f32);
+impl Point {
+    pub fn new(x: f32, y: f32) -> Self {
+        Point(x, y)
+    }
+    pub fn x(&self) -> f32 {
+        self.0
+    }
+    pub fn y(&self) -> f32 {
+        self.1
+    }
+}
+"#####,
+        r#####"
+struct Point { field1: f32, field2: f32 }
+impl Point {
+    pub fn new(x: f32, y: f32) -> Self {
+        Point { field1: x, field2: y }
+    }
+    pub fn x(&self) -> f32 {
+        self.field1
+    }
+    pub fn y(&self) -> f32 {
+        self.field2
+    }
+}
+"#####,
+    )
+}
+#[test]
 fn doctest_expand_glob_import() {
    check_doc_test(
        "expand_glob_import",
diff --git a/crates/ide_assists/src/utils.rs b/crates/ide_assists/src/utils.rs
index d67524937..5a90ad715 100644
--- a/crates/ide_assists/src/utils.rs
+++ b/crates/ide_assists/src/utils.rs
@@ -140,7 +140,8 @@ pub fn add_trait_assoc_items_to_impl(
    let items = items
        .into_iter()
-        .map(|it| ast_transform::apply(&*ast_transform, it))
+        .map(|it| it.clone_for_update())
+        .inspect(|it| ast_transform::apply(&*ast_transform, it))
        .map(|it| match it {
            ast::AssocItem::Fn(def) => ast::AssocItem::Fn(add_body(def)),
            ast::AssocItem::TypeAlias(def) => ast::AssocItem::TypeAlias(def.remove_bounds()),
diff --git a/crates/ide_completion/src/completions/flyimport.rs b/crates/ide_completion/src/completions/flyimport.rs
index 8e211ae1e..9d5b61562 100644
--- a/crates/ide_completion/src/completions/flyimport.rs
+++ b/crates/ide_completion/src/completions/flyimport.rs
@@ -132,7 +132,7 @@ pub(crate) fn import_on_the_fly(acc: &mut Completions, ctx: &CompletionContext)
    let user_input_lowercased = potential_import_name.to_lowercase();
    let import_assets = import_assets(ctx, potential_import_name)?;
-    let import_scope = ImportScope::find_insert_use_container(
+    let import_scope = ImportScope::find_insert_use_container_with_macros(
        position_for_import(ctx, Some(import_assets.import_candidate()))?,
        &ctx.sema,
    )?;
diff --git a/crates/ide_completion/src/item.rs b/crates/ide_completion/src/item.rs
index 16991b688..99edb9499 100644
--- a/crates/ide_completion/src/item.rs
+++ b/crates/ide_completion/src/item.rs
@@ -377,11 +377,11 @@ impl ImportEdit {
    pub fn to_text_edit(&self, cfg: InsertUseConfig) -> Option<TextEdit> {
        let _p = profile::span("ImportEdit::to_text_edit");
-        let rewriter =
+        let new_ast = self.scope.clone_for_update();
-            insert_use::insert_use(&self.scope, mod_path_to_ast(&self.import.import_path), cfg);
+        insert_use::insert_use(&new_ast, mod_path_to_ast(&self.import.import_path), cfg);
-        let old_ast = rewriter.rewrite_root()?;
        let mut import_insert = TextEdit::builder();
-        algo::diff(&old_ast, &rewriter.rewrite(&old_ast)).into_text_edit(&mut import_insert);
+        algo::diff(self.scope.as_syntax_node(), new_ast.as_syntax_node())
+            .into_text_edit(&mut import_insert);
        Some(import_insert.finish())
    }
diff --git a/crates/ide_completion/src/lib.rs b/crates/ide_completion/src/lib.rs
index 6f3d5c5c5..e32633565 100644
--- a/crates/ide_completion/src/lib.rs
+++ b/crates/ide_completion/src/lib.rs
@@ -179,7 +179,7 @@ pub fn resolve_completion_edits(
 ) -> Option<Vec<TextEdit>> {
    let ctx = CompletionContext::new(db, position, config)?;
    let position_for_import = position_for_import(&ctx, None)?;
-    let scope = ImportScope::find_insert_use_container(position_for_import, &ctx.sema)?;
+    let scope = ImportScope::find_insert_use_container_with_macros(position_for_import, &ctx.sema)?;
    let current_module = ctx.sema.scope(position_for_import).module()?;
    let current_crate = current_module.krate();
diff --git a/crates/ide_completion/src/test_utils.rs b/crates/ide_completion/src/test_utils.rs
index 9da844031..c9857ec5f 100644
--- a/crates/ide_completion/src/test_utils.rs
+++ b/crates/ide_completion/src/test_utils.rs
@@ -3,10 +3,7 @@
 use hir::{PrefixKind, Semantics};
 use ide_db::{
    base_db::{fixture::ChangeFixture, FileLoader, FilePosition},
-    helpers::{
+    helpers::{insert_use::InsertUseConfig, merge_imports::MergeBehavior, SnippetCap},
-        insert_use::{InsertUseConfig, MergeBehavior},
-        SnippetCap,
-    },
    RootDatabase,
 };
 use itertools::Itertools;
diff --git a/crates/ide_db/src/helpers.rs b/crates/ide_db/src/helpers.rs
index 720de0d1f..21b48237a 100644
--- a/crates/ide_db/src/helpers.rs
+++ b/crates/ide_db/src/helpers.rs
@@ -1,6 +1,7 @@
 //! A module with ide helpers for high-level ide features.
-pub mod insert_use;
 pub mod import_assets;
+pub mod insert_use;
+pub mod merge_imports;
 pub mod rust_doc;
 use std::collections::VecDeque;
diff --git a/crates/ide_db/src/helpers/insert_use.rs b/crates/ide_db/src/helpers/insert_use.rs
index be3a22725..55cdc4da3 100644
--- a/crates/ide_db/src/helpers/insert_use.rs
+++ b/crates/ide_db/src/helpers/insert_use.rs
@@ -1,19 +1,17 @@
 //! Handle syntactic aspects of inserting a new `use`.
-use std::{cmp::Ordering, iter::successors};
+use std::cmp::Ordering;
 use hir::Semantics;
-use itertools::{EitherOrBoth, Itertools};
 use syntax::{
-    algo::SyntaxRewriter,
+    algo,
-    ast::{
+    ast::{self, make, AstNode, PathSegmentKind},
-        self,
+    ted, AstToken, Direction, NodeOrToken, SyntaxNode, SyntaxToken,
-        edit::{AstNodeEdit, IndentLevel},
-        make, AstNode, AttrsOwner, PathSegmentKind, VisibilityOwner,
-    },
-    AstToken, InsertPosition, NodeOrToken, SyntaxElement, SyntaxNode, SyntaxToken,
 };
-use crate::RootDatabase;
+use crate::{
+    helpers::merge_imports::{try_merge_imports, use_tree_path_cmp, MergeBehavior},
+    RootDatabase,
+};
 pub use hir::PrefixKind;
@@ -42,13 +40,18 @@ impl ImportScope {
    }
    /// Determines the containing syntax node in which to insert a `use` statement affecting `position`.
-    pub fn find_insert_use_container(
+    pub fn find_insert_use_container_with_macros(
        position: &SyntaxNode,
        sema: &Semantics<'_, RootDatabase>,
    ) -> Option<Self> {
        sema.ancestors_with_macros(position.clone()).find_map(Self::from)
    }
+    /// Determines the containing syntax node in which to insert a `use` statement affecting `position`.
+    pub fn find_insert_use_container(position: &SyntaxNode) -> Option<Self> {
+        std::iter::successors(Some(position.clone()), SyntaxNode::parent).find_map(Self::from)
+    }
    pub fn as_syntax_node(&self) -> &SyntaxNode {
        match self {
            ImportScope::File(file) => file.syntax(),
@@ -56,434 +59,32 @@ impl ImportScope {
        }
    }
-    fn indent_level(&self) -> IndentLevel {
+    pub fn clone_for_update(&self) -> Self {
        match self {
-            ImportScope::File(file) => file.indent_level(),
+            ImportScope::File(file) => ImportScope::File(file.clone_for_update()),
-            ImportScope::Module(item_list) => item_list.indent_level() + 1,
+            ImportScope::Module(item_list) => ImportScope::Module(item_list.clone_for_update()),
        }
    }
-    fn first_insert_pos(&self) -> (InsertPosition<SyntaxElement>, AddBlankLine) {
-        match self {
-            ImportScope::File(_) => (InsertPosition::First, AddBlankLine::AfterTwice),
-            // don't insert the imports before the item list's opening curly brace
-            ImportScope::Module(item_list) => item_list
-                .l_curly_token()
-                .map(|b| (InsertPosition::After(b.into()), AddBlankLine::Around))
-                .unwrap_or((InsertPosition::First, AddBlankLine::AfterTwice)),
-        }
-    }
-    fn insert_pos_after_last_inner_element(&self) -> (InsertPosition<SyntaxElement>, AddBlankLine) {
-        self.as_syntax_node()
-            .children_with_tokens()
-            .filter(|child| match child {
-                NodeOrToken::Node(node) => is_inner_attribute(node.clone()),
-                NodeOrToken::Token(token) => is_inner_comment(token.clone()),
-            })
-            .last()
-            .map(|last_inner_element| {
-                (InsertPosition::After(last_inner_element), AddBlankLine::BeforeTwice)
-            })
-            .unwrap_or_else(|| self.first_insert_pos())
-    }
-}
-fn is_inner_attribute(node: SyntaxNode) -> bool {
-    ast::Attr::cast(node).map(|attr| attr.kind()) == Some(ast::AttrKind::Inner)
-}
-fn is_inner_comment(token: SyntaxToken) -> bool {
-    ast::Comment::cast(token).and_then(|comment| comment.kind().doc)
-        == Some(ast::CommentPlacement::Inner)
 }
 /// Insert an import path into the given file/node. A `merge` value of none indicates that no import merging is allowed to occur.
-pub fn insert_use<'a>(
+pub fn insert_use<'a>(scope: &ImportScope, path: ast::Path, cfg: InsertUseConfig) {
-    scope: &ImportScope,
-    path: ast::Path,
-    cfg: InsertUseConfig,
-) -> SyntaxRewriter<'a> {
    let _p = profile::span("insert_use");
-    let mut rewriter = SyntaxRewriter::default();
+    let use_item =
-    let use_item = make::use_(None, make::use_tree(path.clone(), None, None, false));
+        make::use_(None, make::use_tree(path.clone(), None, None, false)).clone_for_update();
    // merge into existing imports if possible
    if let Some(mb) = cfg.merge {
        for existing_use in scope.as_syntax_node().children().filter_map(ast::Use::cast) {
            if let Some(merged) = try_merge_imports(&existing_use, &use_item, mb) {
-                rewriter.replace(existing_use.syntax(), merged.syntax());
+                ted::replace(existing_use.syntax(), merged.syntax());
-                return rewriter;
+                return;
            }
        }
    }
    // either we weren't allowed to merge or there is no import that fits the merge conditions
    // so look for the place we have to insert to
-    let (insert_position, add_blank) = find_insert_position(scope, path, cfg.group);
+    insert_use_(scope, path, cfg.group, use_item);
-    let indent = if let ident_level @ 1..=usize::MAX = scope.indent_level().0 as usize {
-        Some(make::tokens::whitespace(&" ".repeat(4 * ident_level)).into())
-    } else {
-        None
-    };
-    let to_insert: Vec<SyntaxElement> = {
-        let mut buf = Vec::new();
-        match add_blank {
-            AddBlankLine::Before | AddBlankLine::Around => {
-                buf.push(make::tokens::single_newline().into())
-            }
-            AddBlankLine::BeforeTwice => buf.push(make::tokens::blank_line().into()),
-            _ => (),
-        }
-        if add_blank.has_before() {
-            if let Some(indent) = indent.clone() {
-                cov_mark::hit!(insert_use_indent_before);
-                buf.push(indent);
-            }
-        }
-        buf.push(use_item.syntax().clone().into());
-        match add_blank {
-            AddBlankLine::After | AddBlankLine::Around => {
-                buf.push(make::tokens::single_newline().into())
-            }
-            AddBlankLine::AfterTwice => buf.push(make::tokens::blank_line().into()),
-            _ => (),
-        }
-        // only add indentation *after* our stuff if there's another node directly after it
-        if add_blank.has_after() && matches!(insert_position, InsertPosition::Before(_)) {
-            if let Some(indent) = indent {
-                cov_mark::hit!(insert_use_indent_after);
-                buf.push(indent);
-            }
-        } else if add_blank.has_after() && matches!(insert_position, InsertPosition::After(_)) {
-            cov_mark::hit!(insert_use_no_indent_after);
-        }
-        buf
-    };
-    match insert_position {
-        InsertPosition::First => {
-            rewriter.insert_many_as_first_children(scope.as_syntax_node(), to_insert)
-        }
-        InsertPosition::Last => return rewriter, // actually unreachable
-        InsertPosition::Before(anchor) => rewriter.insert_many_before(&anchor, to_insert),
-        InsertPosition::After(anchor) => rewriter.insert_many_after(&anchor, to_insert),
-    }
-    rewriter
-}
-fn eq_visibility(vis0: Option<ast::Visibility>, vis1: Option<ast::Visibility>) -> bool {
-    match (vis0, vis1) {
-        (None, None) => true,
-        // FIXME: Don't use the string representation to check for equality
-        // spaces inside of the node would break this comparison
-        (Some(vis0), Some(vis1)) => vis0.to_string() == vis1.to_string(),
-        _ => false,
-    }
-}
-fn eq_attrs(
-    attrs0: impl Iterator<Item = ast::Attr>,
-    attrs1: impl Iterator<Item = ast::Attr>,
-) -> bool {
-    let attrs0 = attrs0.map(|attr| attr.to_string());
-    let attrs1 = attrs1.map(|attr| attr.to_string());
-    attrs0.eq(attrs1)
-}
-pub fn try_merge_imports(
-    lhs: &ast::Use,
-    rhs: &ast::Use,
-    merge_behavior: MergeBehavior,
-) -> Option<ast::Use> {
-    // don't merge imports with different visibilities
-    if !eq_visibility(lhs.visibility(), rhs.visibility()) {
-        return None;
-    }
-    if !eq_attrs(lhs.attrs(), rhs.attrs()) {
-        return None;
-    }
-    let lhs_tree = lhs.use_tree()?;
-    let rhs_tree = rhs.use_tree()?;
-    let merged = try_merge_trees(&lhs_tree, &rhs_tree, merge_behavior)?;
-    Some(lhs.with_use_tree(merged).clone_for_update())
-}
-pub fn try_merge_trees(
-    lhs: &ast::UseTree,
-    rhs: &ast::UseTree,
-    merge: MergeBehavior,
-) -> Option<ast::UseTree> {
-    let lhs_path = lhs.path()?;
-    let rhs_path = rhs.path()?;
-    let (lhs_prefix, rhs_prefix) = common_prefix(&lhs_path, &rhs_path)?;
-    let (lhs, rhs) = if is_simple_path(lhs)
-        && is_simple_path(rhs)
-        && lhs_path == lhs_prefix
-        && rhs_path == rhs_prefix
-    {
-        (lhs.clone(), rhs.clone())
-    } else {
-        (lhs.split_prefix(&lhs_prefix), rhs.split_prefix(&rhs_prefix))
-    };
-    recursive_merge(&lhs, &rhs, merge).map(|it| it.clone_for_update())
-}
-/// Recursively "zips" together lhs and rhs.
-fn recursive_merge(
-    lhs: &ast::UseTree,
-    rhs: &ast::UseTree,
-    merge: MergeBehavior,
-) -> Option<ast::UseTree> {
-    let mut use_trees = lhs
-        .use_tree_list()
-        .into_iter()
-        .flat_map(|list| list.use_trees())
-        // we use Option here to early return from this function(this is not the same as a `filter` op)
-        .map(|tree| match merge.is_tree_allowed(&tree) {
-            true => Some(tree),
-            false => None,
-        })
-        .collect::<Option<Vec<_>>>()?;
-    use_trees.sort_unstable_by(|a, b| path_cmp_for_sort(a.path(), b.path()));
-    for rhs_t in rhs.use_tree_list().into_iter().flat_map(|list| list.use_trees()) {
-        if !merge.is_tree_allowed(&rhs_t) {
-            return None;
-        }
-        let rhs_path = rhs_t.path();
-        match use_trees.binary_search_by(|lhs_t| {
-            let (lhs_t, rhs_t) = match lhs_t
-                .path()
-                .zip(rhs_path.clone())
-                .and_then(|(lhs, rhs)| common_prefix(&lhs, &rhs))
-            {
-                Some((lhs_p, rhs_p)) => (lhs_t.split_prefix(&lhs_p), rhs_t.split_prefix(&rhs_p)),
-                None => (lhs_t.clone(), rhs_t.clone()),
-            };
-            path_cmp_bin_search(lhs_t.path(), rhs_t.path())
-        }) {
-            Ok(idx) => {
-                let lhs_t = &mut use_trees[idx];
-                let lhs_path = lhs_t.path()?;
-                let rhs_path = rhs_path?;
-                let (lhs_prefix, rhs_prefix) = common_prefix(&lhs_path, &rhs_path)?;
-                if lhs_prefix == lhs_path && rhs_prefix == rhs_path {
-                    let tree_is_self = |tree: ast::UseTree| {
-                        tree.path().as_ref().map(path_is_self).unwrap_or(false)
-                    };
-                    // check if only one of the two trees has a tree list, and whether that then contains `self` or not.
-                    // If this is the case we can skip this iteration since the path without the list is already included in the other one via `self`
-                    let tree_contains_self = |tree: &ast::UseTree| {
-                        tree.use_tree_list()
-                            .map(|tree_list| tree_list.use_trees().any(tree_is_self))
-                            .unwrap_or(false)
-                    };
-                    match (tree_contains_self(&lhs_t), tree_contains_self(&rhs_t)) {
-                        (true, false) => continue,
-                        (false, true) => {
-                            *lhs_t = rhs_t;
-                            continue;
-                        }
-                        _ => (),
-                    }
-                    // glob imports arent part of the use-tree lists so we need to special handle them here as well
-                    // this special handling is only required for when we merge a module import into a glob import of said module
-                    // see the `merge_self_glob` or `merge_mod_into_glob` tests
-                    if lhs_t.star_token().is_some() || rhs_t.star_token().is_some() {
-                        *lhs_t = make::use_tree(
-                            make::path_unqualified(make::path_segment_self()),
-                            None,
-                            None,
-                            false,
-                        );
-                        use_trees.insert(idx, make::glob_use_tree());
-                        continue;
-                    }
-                    if lhs_t.use_tree_list().is_none() && rhs_t.use_tree_list().is_none() {
-                        continue;
-                    }
-                }
-                let lhs = lhs_t.split_prefix(&lhs_prefix);
-                let rhs = rhs_t.split_prefix(&rhs_prefix);
-                match recursive_merge(&lhs, &rhs, merge) {
-                    Some(use_tree) => use_trees[idx] = use_tree,
-                    None => return None,
-                }
-            }
-            Err(_)
-                if merge == MergeBehavior::Last
-                    && use_trees.len() > 0
-                    && rhs_t.use_tree_list().is_some() =>
-            {
-                return None
-            }
-            Err(idx) => {
-                use_trees.insert(idx, rhs_t);
-            }
-        }
-    }
-    Some(lhs.with_use_tree_list(make::use_tree_list(use_trees)))
-}
-/// Traverses both paths until they differ, returning the common prefix of both.
-fn common_prefix(lhs: &ast::Path, rhs: &ast::Path) -> Option<(ast::Path, ast::Path)> {
-    let mut res = None;
-    let mut lhs_curr = first_path(&lhs);
-    let mut rhs_curr = first_path(&rhs);
-    loop {
-        match (lhs_curr.segment(), rhs_curr.segment()) {
-            (Some(lhs), Some(rhs)) if lhs.syntax().text() == rhs.syntax().text() => (),
-            _ => break res,
-        }
-        res = Some((lhs_curr.clone(), rhs_curr.clone()));
-        match lhs_curr.parent_path().zip(rhs_curr.parent_path()) {
-            Some((lhs, rhs)) => {
-                lhs_curr = lhs;
-                rhs_curr = rhs;
-            }
-            _ => break res,
-        }
-    }
-}
-fn is_simple_path(use_tree: &ast::UseTree) -> bool {
-    use_tree.use_tree_list().is_none() && use_tree.star_token().is_none()
-}
-fn path_is_self(path: &ast::Path) -> bool {
-    path.segment().and_then(|seg| seg.self_token()).is_some() && path.qualifier().is_none()
-}
-#[inline]
-fn first_segment(path: &ast::Path) -> Option<ast::PathSegment> {
-    first_path(path).segment()
-}
-fn first_path(path: &ast::Path) -> ast::Path {
-    successors(Some(path.clone()), ast::Path::qualifier).last().unwrap()
-}
-fn segment_iter(path: &ast::Path) -> impl Iterator<Item = ast::PathSegment> + Clone {
-    // cant make use of SyntaxNode::siblings, because the returned Iterator is not clone
-    successors(first_segment(path), |p| p.parent_path().parent_path().and_then(|p| p.segment()))
-}
-fn path_len(path: ast::Path) -> usize {
-    segment_iter(&path).count()
-}
-/// Orders paths in the following way:
-/// the sole self token comes first, after that come uppercase identifiers, then lowercase identifiers
-// FIXME: rustfmt sorts lowercase idents before uppercase, in general we want to have the same ordering rustfmt has
-// which is `self` and `super` first, then identifier imports with lowercase ones first, then glob imports and at last list imports.
-// Example foo::{self, foo, baz, Baz, Qux, *, {Bar}}
-fn path_cmp_for_sort(a: Option<ast::Path>, b: Option<ast::Path>) -> Ordering {
-    match (a, b) {
-        (None, None) => Ordering::Equal,
-        (None, Some(_)) => Ordering::Less,
-        (Some(_), None) => Ordering::Greater,
-        (Some(ref a), Some(ref b)) => match (path_is_self(a), path_is_self(b)) {
-            (true, true) => Ordering::Equal,
-            (true, false) => Ordering::Less,
-            (false, true) => Ordering::Greater,
-            (false, false) => path_cmp_short(a, b),
-        },
-    }
-}
-/// Path comparison func for binary searching for merging.
-fn path_cmp_bin_search(lhs: Option<ast::Path>, rhs: Option<ast::Path>) -> Ordering {
-    match (lhs.as_ref().and_then(first_segment), rhs.as_ref().and_then(first_segment)) {
-        (None, None) => Ordering::Equal,
-        (None, Some(_)) => Ordering::Less,
-        (Some(_), None) => Ordering::Greater,
-        (Some(ref a), Some(ref b)) => path_segment_cmp(a, b),
-    }
-}
-/// Short circuiting comparison, if both paths are equal until one of them ends they are considered
-/// equal
-fn path_cmp_short(a: &ast::Path, b: &ast::Path) -> Ordering {
-    let a = segment_iter(a);
-    let b = segment_iter(b);
-    // cmp_by would be useful for us here but that is currently unstable
-    // cmp doesnt work due the lifetimes on text's return type
-    a.zip(b)
-        .find_map(|(a, b)| match path_segment_cmp(&a, &b) {
-            Ordering::Equal => None,
-            ord => Some(ord),
-        })
-        .unwrap_or(Ordering::Equal)
-}
-/// Compares to paths, if one ends earlier than the other the has_tl parameters decide which is
-/// greater as a a path that has a tree list should be greater, while one that just ends without
-/// a tree list should be considered less.
-fn use_tree_path_cmp(a: &ast::Path, a_has_tl: bool, b: &ast::Path, b_has_tl: bool) -> Ordering {
-    let a_segments = segment_iter(a);
-    let b_segments = segment_iter(b);
-    // cmp_by would be useful for us here but that is currently unstable
-    // cmp doesnt work due the lifetimes on text's return type
-    a_segments
-        .zip_longest(b_segments)
-        .find_map(|zipped| match zipped {
-            EitherOrBoth::Both(ref a, ref b) => match path_segment_cmp(a, b) {
-                Ordering::Equal => None,
-                ord => Some(ord),
-            },
-            EitherOrBoth::Left(_) if !b_has_tl => Some(Ordering::Greater),
-            EitherOrBoth::Left(_) => Some(Ordering::Less),
-            EitherOrBoth::Right(_) if !a_has_tl => Some(Ordering::Less),
-            EitherOrBoth::Right(_) => Some(Ordering::Greater),
-        })
-        .unwrap_or(Ordering::Equal)
-}
-fn path_segment_cmp(a: &ast::PathSegment, b: &ast::PathSegment) -> Ordering {
-    let a = a.kind().and_then(|kind| match kind {
-        PathSegmentKind::Name(name_ref) => Some(name_ref),
-        _ => None,
-    });
-    let b = b.kind().and_then(|kind| match kind {
-        PathSegmentKind::Name(name_ref) => Some(name_ref),
-        _ => None,
-    });
-    a.as_ref().map(ast::NameRef::text).cmp(&b.as_ref().map(ast::NameRef::text))
-}
-/// What type of merges are allowed.
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub enum MergeBehavior {
-    /// Merge everything together creating deeply nested imports.
-    Full,
-    /// Only merge the last import level, doesn't allow import nesting.
-    Last,
-}
-impl MergeBehavior {
-    #[inline]
-    fn is_tree_allowed(&self, tree: &ast::UseTree) -> bool {
-        match self {
-            MergeBehavior::Full => true,
-            // only simple single segment paths are allowed
-            MergeBehavior::Last => {
-                tree.use_tree_list().is_none() && tree.path().map(path_len) <= Some(1)
-            }
-        }
-    }
 }
 #[derive(Eq, PartialEq, PartialOrd, Ord)]
@@ -500,7 +101,7 @@ impl ImportGroup {
    fn new(path: &ast::Path) -> ImportGroup {
        let default = ImportGroup::ExternCrate;
-        let first_segment = match first_segment(path) {
+        let first_segment = match path.first_segment() {
            Some(it) => it,
            None => return default,
        };
@@ -520,32 +121,15 @@ impl ImportGroup {
    }
 }
-#[derive(PartialEq, Eq)]
+fn insert_use_(
-enum AddBlankLine {
-    Before,
-    BeforeTwice,
-    Around,
-    After,
-    AfterTwice,
-}
-impl AddBlankLine {
-    fn has_before(&self) -> bool {
-        matches!(self, AddBlankLine::Before | AddBlankLine::BeforeTwice | AddBlankLine::Around)
-    }
-    fn has_after(&self) -> bool {
-        matches!(self, AddBlankLine::After | AddBlankLine::AfterTwice | AddBlankLine::Around)
-    }
-}
-fn find_insert_position(
    scope: &ImportScope,
    insert_path: ast::Path,
    group_imports: bool,
-) -> (InsertPosition<SyntaxElement>, AddBlankLine) {
+    use_item: ast::Use,
+) {
+    let scope_syntax = scope.as_syntax_node();
    let group = ImportGroup::new(&insert_path);
-    let path_node_iter = scope
+    let path_node_iter = scope_syntax
-        .as_syntax_node()
        .children()
        .filter_map(|node| ast::Use::cast(node.clone()).zip(Some(node)))
        .flat_map(|(use_, node)| {
@@ -557,9 +141,14 @@ fn find_insert_position(
    if !group_imports {
        if let Some((_, _, node)) = path_node_iter.last() {
-            return (InsertPosition::After(node.into()), AddBlankLine::Before);
+            cov_mark::hit!(insert_no_grouping_last);
+            ted::insert(ted::Position::after(node), use_item.syntax());
+        } else {
+            cov_mark::hit!(insert_no_grouping_last2);
+            ted::insert(ted::Position::first_child_of(scope_syntax), make::tokens::blank_line());
+            ted::insert(ted::Position::first_child_of(scope_syntax), use_item.syntax());
        }
-        return (InsertPosition::First, AddBlankLine::AfterTwice);
+        return;
    }
    // Iterator that discards anything thats not in the required grouping
@@ -572,43 +161,91 @@ fn find_insert_position(
    // track the last element we iterated over, if this is still None after the iteration then that means we never iterated in the first place
    let mut last = None;
    // find the element that would come directly after our new import
-    let post_insert = group_iter.inspect(|(.., node)| last = Some(node.clone())).find(
+    let post_insert: Option<(_, _, SyntaxNode)> = group_iter
-        |&(ref path, has_tl, _)| {
+        .inspect(|(.., node)| last = Some(node.clone()))
+        .find(|&(ref path, has_tl, _)| {
            use_tree_path_cmp(&insert_path, false, path, has_tl) != Ordering::Greater
-        },
+        });
-    );
-    match post_insert {
+    if let Some((.., node)) = post_insert {
+        cov_mark::hit!(insert_group);
        // insert our import before that element
-        Some((.., node)) => (InsertPosition::Before(node.into()), AddBlankLine::After),
+        return ted::insert(ted::Position::before(node), use_item.syntax());
+    }
+    if let Some(node) = last {
+        cov_mark::hit!(insert_group_last);
        // there is no element after our new import, so append it to the end of the group
-        None => match last {
+        return ted::insert(ted::Position::after(node), use_item.syntax());
-            Some(node) => (InsertPosition::After(node.into()), AddBlankLine::Before),
+    }
-            // the group we were looking for actually doesnt exist, so insert
+    // the group we were looking for actually doesn't exist, so insert
+    let mut last = None;
+    // find the group that comes after where we want to insert
+    let post_group = path_node_iter
+        .inspect(|(.., node)| last = Some(node.clone()))
+        .find(|(p, ..)| ImportGroup::new(p) > group);
+    if let Some((.., node)) = post_group {
+        cov_mark::hit!(insert_group_new_group);
+        ted::insert(ted::Position::before(&node), use_item.syntax());
+        if let Some(node) = algo::non_trivia_sibling(node.into(), Direction::Prev) {
+            ted::insert(ted::Position::after(node), make::tokens::single_newline());
+        }
+        return;
+    }
+    // there is no such group, so append after the last one
+    if let Some(node) = last {
+        cov_mark::hit!(insert_group_no_group);
+        ted::insert(ted::Position::after(&node), use_item.syntax());
+        ted::insert(ted::Position::after(node), make::tokens::single_newline());
+        return;
+    }
+    // there are no imports in this file at all
+    if let Some(last_inner_element) = scope_syntax
+        .children_with_tokens()
+        .filter(|child| match child {
+            NodeOrToken::Node(node) => is_inner_attribute(node.clone()),
+            NodeOrToken::Token(token) => is_inner_comment(token.clone()),
+        })
+        .last()
+    {
+        cov_mark::hit!(insert_group_empty_inner_attr);
+        ted::insert(ted::Position::after(&last_inner_element), use_item.syntax());
+        ted::insert(ted::Position::after(last_inner_element), make::tokens::single_newline());
+        return;
+    }
+    match scope {
+        ImportScope::File(_) => {
+            cov_mark::hit!(insert_group_empty_file);
+            ted::insert(ted::Position::first_child_of(scope_syntax), make::tokens::blank_line());
+            ted::insert(ted::Position::first_child_of(scope_syntax), use_item.syntax())
+        }
+        // don't insert the imports before the item list's opening curly brace
+        ImportScope::Module(item_list) => match item_list.l_curly_token() {
+            Some(b) => {
+                cov_mark::hit!(insert_group_empty_module);
+                ted::insert(ted::Position::after(&b), make::tokens::single_newline());
+                ted::insert(ted::Position::after(&b), use_item.syntax());
+            }
            None => {
-                // similar concept here to the `last` from above
+                // This should never happens, broken module syntax node
-                let mut last = None;
+                ted::insert(
-                // find the group that comes after where we want to insert
+                    ted::Position::first_child_of(scope_syntax),
-                let post_group = path_node_iter
+                    make::tokens::blank_line(),
-                    .inspect(|(.., node)| last = Some(node.clone()))
+                );
-                    .find(|(p, ..)| ImportGroup::new(p) > group);
+                ted::insert(ted::Position::first_child_of(scope_syntax), use_item.syntax());
-                match post_group {
-                    Some((.., node)) => {
-                        (InsertPosition::Before(node.into()), AddBlankLine::AfterTwice)
-                    }
-                    // there is no such group, so append after the last one
-                    None => match last {
-                        Some(node) => {
-                            (InsertPosition::After(node.into()), AddBlankLine::BeforeTwice)
-                        }
-                        // there are no imports in this file at all
-                        None => scope.insert_pos_after_last_inner_element(),
-                    },
-                }
            }
        },
    }
 }
+fn is_inner_attribute(node: SyntaxNode) -> bool {
+    ast::Attr::cast(node).map(|attr| attr.kind()) == Some(ast::AttrKind::Inner)
+}
+fn is_inner_comment(token: SyntaxToken) -> bool {
+    ast::Comment::cast(token).and_then(|comment| comment.kind().doc)
+        == Some(ast::CommentPlacement::Inner)
+}
 #[cfg(test)]
 mod tests;
diff --git a/crates/ide_db/src/helpers/insert_use/tests.rs b/crates/ide_db/src/helpers/insert_use/tests.rs
index 3d151e629..048c213e2 100644
--- a/crates/ide_db/src/helpers/insert_use/tests.rs
+++ b/crates/ide_db/src/helpers/insert_use/tests.rs
@@ -5,6 +5,7 @@ use test_utils::assert_eq_text;
 #[test]
 fn insert_not_group() {
+    cov_mark::check!(insert_no_grouping_last);
    check(
        "use external_crate2::bar::A",
        r"
@@ -27,6 +28,21 @@ use external_crate2::bar::A;",
 }
 #[test]
+fn insert_not_group_empty() {
+    cov_mark::check!(insert_no_grouping_last2);
+    check(
+        "use external_crate2::bar::A",
+        r"",
+        r"use external_crate2::bar::A;
+",
+        None,
+        false,
+        false,
+    );
+}
+#[test]
 fn insert_existing() {
    check_full("std::fs", "use std::fs;", "use std::fs;")
 }
@@ -51,21 +67,21 @@ use std::bar::G;",
 #[test]
 fn insert_start_indent() {
-    cov_mark::check!(insert_use_indent_after);
    check_none(
        "std::bar::AA",
        r"
    use std::bar::B;
-    use std::bar::D;",
+    use std::bar::C;",
        r"
    use std::bar::AA;
    use std::bar::B;
-    use std::bar::D;",
+    use std::bar::C;",
-    )
+    );
 }
 #[test]
 fn insert_middle() {
+    cov_mark::check!(insert_group);
    check_none(
        "std::bar::EE",
        r"
@@ -102,6 +118,7 @@ fn insert_middle_indent() {
 #[test]
 fn insert_end() {
+    cov_mark::check!(insert_group_last);
    check_none(
        "std::bar::ZZ",
        r"
@@ -120,7 +137,6 @@ use std::bar::ZZ;",
 #[test]
 fn insert_end_indent() {
-    cov_mark::check!(insert_use_indent_before);
    check_none(
        "std::bar::ZZ",
        r"
@@ -201,6 +217,7 @@ fn insert_first_matching_group() {
 #[test]
 fn insert_missing_group_std() {
+    cov_mark::check!(insert_group_new_group);
    check_none(
        "std::fmt",
        r"
@@ -216,6 +233,7 @@ fn insert_missing_group_std() {
 #[test]
 fn insert_missing_group_self() {
+    cov_mark::check!(insert_group_no_group);
    check_none(
        "self::fmt",
        r"
@@ -242,6 +260,7 @@ fn main() {}",
 #[test]
 fn insert_empty_file() {
+    cov_mark::check!(insert_group_empty_file);
    // empty files will get two trailing newlines
    // this is due to the test case insert_no_imports above
    check_full(
@@ -255,7 +274,7 @@ fn insert_empty_file() {
 #[test]
 fn insert_empty_module() {
-    cov_mark::check!(insert_use_no_indent_after);
+    cov_mark::check!(insert_group_empty_module);
    check(
        "foo::bar",
        "mod x {}",
@@ -270,6 +289,7 @@ fn insert_empty_module() {
 #[test]
 fn insert_after_inner_attr() {
+    cov_mark::check!(insert_group_empty_inner_attr);
    check_full(
        "foo::bar",
        r"#![allow(unused_imports)]",
@@ -615,7 +635,7 @@ fn check(
    if module {
        syntax = syntax.descendants().find_map(ast::Module::cast).unwrap().syntax().clone();
    }
-    let file = super::ImportScope::from(syntax).unwrap();
+    let file = super::ImportScope::from(syntax.clone_for_update()).unwrap();
    let path = ast::SourceFile::parse(&format!("use {};", path))
        .tree()
        .syntax()
@@ -623,12 +643,8 @@ fn check(
        .find_map(ast::Path::cast)
        .unwrap();
-    let rewriter = insert_use(
+    insert_use(&file, path, InsertUseConfig { merge: mb, prefix_kind: PrefixKind::Plain, group });
-        &file,
+    let result = file.as_syntax_node().to_string();
-        path,
-        InsertUseConfig { merge: mb, prefix_kind: PrefixKind::Plain, group },
-    );
-    let result = rewriter.rewrite(file.as_syntax_node()).to_string();
    assert_eq_text!(ra_fixture_after, &result);
 }
diff --git a/crates/ide_db/src/helpers/merge_imports.rs b/crates/ide_db/src/helpers/merge_imports.rs
new file mode 100644
index 000000000..3f5bbef7f
--- /dev/null
+++ b/crates/ide_db/src/helpers/merge_imports.rs
@@ -0,0 +1,309 @@
+//! Handle syntactic aspects of merging UseTrees.
+use std::cmp::Ordering;
+use itertools::{EitherOrBoth, Itertools};
+use syntax::ast::{
+    self, edit::AstNodeEdit, make, AstNode, AttrsOwner, PathSegmentKind, VisibilityOwner,
+};
+/// What type of merges are allowed.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum MergeBehavior {
+    /// Merge everything together creating deeply nested imports.
+    Full,
+    /// Only merge the last import level, doesn't allow import nesting.
+    Last,
+}
+impl MergeBehavior {
+    #[inline]
+    fn is_tree_allowed(&self, tree: &ast::UseTree) -> bool {
+        match self {
+            MergeBehavior::Full => true,
+            // only simple single segment paths are allowed
+            MergeBehavior::Last => {
+                tree.use_tree_list().is_none() && tree.path().map(path_len) <= Some(1)
+            }
+        }
+    }
+}
+pub fn try_merge_imports(
+    lhs: &ast::Use,
+    rhs: &ast::Use,
+    merge_behavior: MergeBehavior,
+) -> Option<ast::Use> {
+    // don't merge imports with different visibilities
+    if !eq_visibility(lhs.visibility(), rhs.visibility()) {
+        return None;
+    }
+    if !eq_attrs(lhs.attrs(), rhs.attrs()) {
+        return None;
+    }
+    let lhs_tree = lhs.use_tree()?;
+    let rhs_tree = rhs.use_tree()?;
+    let merged = try_merge_trees(&lhs_tree, &rhs_tree, merge_behavior)?;
+    Some(lhs.with_use_tree(merged).clone_for_update())
+}
+pub fn try_merge_trees(
+    lhs: &ast::UseTree,
+    rhs: &ast::UseTree,
+    merge: MergeBehavior,
+) -> Option<ast::UseTree> {
+    let lhs_path = lhs.path()?;
+    let rhs_path = rhs.path()?;
+    let (lhs_prefix, rhs_prefix) = common_prefix(&lhs_path, &rhs_path)?;
+    let (lhs, rhs) = if lhs.is_simple_path()
+        && rhs.is_simple_path()
+        && lhs_path == lhs_prefix
+        && rhs_path == rhs_prefix
+    {
+        (lhs.clone(), rhs.clone())
+    } else {
+        (lhs.split_prefix(&lhs_prefix), rhs.split_prefix(&rhs_prefix))
+    };
+    recursive_merge(&lhs, &rhs, merge)
+}
+/// Recursively "zips" together lhs and rhs.
+fn recursive_merge(
+    lhs: &ast::UseTree,
+    rhs: &ast::UseTree,
+    merge: MergeBehavior,
+) -> Option<ast::UseTree> {
+    let mut use_trees = lhs
+        .use_tree_list()
+        .into_iter()
+        .flat_map(|list| list.use_trees())
+        // we use Option here to early return from this function(this is not the same as a `filter` op)
+        .map(|tree| match merge.is_tree_allowed(&tree) {
+            true => Some(tree),
+            false => None,
+        })
+        .collect::<Option<Vec<_>>>()?;
+    use_trees.sort_unstable_by(|a, b| path_cmp_for_sort(a.path(), b.path()));
+    for rhs_t in rhs.use_tree_list().into_iter().flat_map(|list| list.use_trees()) {
+        if !merge.is_tree_allowed(&rhs_t) {
+            return None;
+        }
+        let rhs_path = rhs_t.path();
+        match use_trees.binary_search_by(|lhs_t| {
+            let (lhs_t, rhs_t) = match lhs_t
+                .path()
+                .zip(rhs_path.clone())
+                .and_then(|(lhs, rhs)| common_prefix(&lhs, &rhs))
+            {
+                Some((lhs_p, rhs_p)) => (lhs_t.split_prefix(&lhs_p), rhs_t.split_prefix(&rhs_p)),
+                None => (lhs_t.clone(), rhs_t.clone()),
+            };
+            path_cmp_bin_search(lhs_t.path(), rhs_t.path())
+        }) {
+            Ok(idx) => {
+                let lhs_t = &mut use_trees[idx];
+                let lhs_path = lhs_t.path()?;
+                let rhs_path = rhs_path?;
+                let (lhs_prefix, rhs_prefix) = common_prefix(&lhs_path, &rhs_path)?;
+                if lhs_prefix == lhs_path && rhs_prefix == rhs_path {
+                    let tree_is_self = |tree: ast::UseTree| {
+                        tree.path().as_ref().map(path_is_self).unwrap_or(false)
+                    };
+                    // check if only one of the two trees has a tree list, and whether that then contains `self` or not.
+                    // If this is the case we can skip this iteration since the path without the list is already included in the other one via `self`
+                    let tree_contains_self = |tree: &ast::UseTree| {
+                        tree.use_tree_list()
+                            .map(|tree_list| tree_list.use_trees().any(tree_is_self))
+                            .unwrap_or(false)
+                    };
+                    match (tree_contains_self(&lhs_t), tree_contains_self(&rhs_t)) {
+                        (true, false) => continue,
+                        (false, true) => {
+                            *lhs_t = rhs_t;
+                            continue;
+                        }
+                        _ => (),
+                    }
+                    // glob imports arent part of the use-tree lists so we need to special handle them here as well
+                    // this special handling is only required for when we merge a module import into a glob import of said module
+                    // see the `merge_self_glob` or `merge_mod_into_glob` tests
+                    if lhs_t.star_token().is_some() || rhs_t.star_token().is_some() {
+                        *lhs_t = make::use_tree(
+                            make::path_unqualified(make::path_segment_self()),
+                            None,
+                            None,
+                            false,
+                        );
+                        use_trees.insert(idx, make::glob_use_tree());
+                        continue;
+                    }
+                    if lhs_t.use_tree_list().is_none() && rhs_t.use_tree_list().is_none() {
+                        continue;
+                    }
+                }
+                let lhs = lhs_t.split_prefix(&lhs_prefix);
+                let rhs = rhs_t.split_prefix(&rhs_prefix);
+                match recursive_merge(&lhs, &rhs, merge) {
+                    Some(use_tree) => use_trees[idx] = use_tree,
+                    None => return None,
+                }
+            }
+            Err(_)
+                if merge == MergeBehavior::Last
+                    && use_trees.len() > 0
+                    && rhs_t.use_tree_list().is_some() =>
+            {
+                return None
+            }
+            Err(idx) => {
+                use_trees.insert(idx, rhs_t);
+            }
+        }
+    }
+    Some(if let Some(old) = lhs.use_tree_list() {
+        lhs.replace_descendant(old, make::use_tree_list(use_trees)).clone_for_update()
+    } else {
+        lhs.clone()
+    })
+}
+/// Traverses both paths until they differ, returning the common prefix of both.
+fn common_prefix(lhs: &ast::Path, rhs: &ast::Path) -> Option<(ast::Path, ast::Path)> {
+    let mut res = None;
+    let mut lhs_curr = lhs.first_qualifier_or_self();
+    let mut rhs_curr = rhs.first_qualifier_or_self();
+    loop {
+        match (lhs_curr.segment(), rhs_curr.segment()) {
+            (Some(lhs), Some(rhs)) if lhs.syntax().text() == rhs.syntax().text() => (),
+            _ => break res,
+        }
+        res = Some((lhs_curr.clone(), rhs_curr.clone()));
+        match lhs_curr.parent_path().zip(rhs_curr.parent_path()) {
+            Some((lhs, rhs)) => {
+                lhs_curr = lhs;
+                rhs_curr = rhs;
+            }
+            _ => break res,
+        }
+    }
+}
+/// Orders paths in the following way:
+/// the sole self token comes first, after that come uppercase identifiers, then lowercase identifiers
+// FIXME: rustfmt sorts lowercase idents before uppercase, in general we want to have the same ordering rustfmt has
+// which is `self` and `super` first, then identifier imports with lowercase ones first, then glob imports and at last list imports.
+// Example foo::{self, foo, baz, Baz, Qux, *, {Bar}}
+fn path_cmp_for_sort(a: Option<ast::Path>, b: Option<ast::Path>) -> Ordering {
+    match (a, b) {
+        (None, None) => Ordering::Equal,
+        (None, Some(_)) => Ordering::Less,
+        (Some(_), None) => Ordering::Greater,
+        (Some(ref a), Some(ref b)) => match (path_is_self(a), path_is_self(b)) {
+            (true, true) => Ordering::Equal,
+            (true, false) => Ordering::Less,
+            (false, true) => Ordering::Greater,
+            (false, false) => path_cmp_short(a, b),
+        },
+    }
+}
+/// Path comparison func for binary searching for merging.
+fn path_cmp_bin_search(lhs: Option<ast::Path>, rhs: Option<ast::Path>) -> Ordering {
+    match (
+        lhs.as_ref().and_then(ast::Path::first_segment),
+        rhs.as_ref().and_then(ast::Path::first_segment),
+    ) {
+        (None, None) => Ordering::Equal,
+        (None, Some(_)) => Ordering::Less,
+        (Some(_), None) => Ordering::Greater,
+        (Some(ref a), Some(ref b)) => path_segment_cmp(a, b),
+    }
+}
+/// Short circuiting comparison, if both paths are equal until one of them ends they are considered
+/// equal
+fn path_cmp_short(a: &ast::Path, b: &ast::Path) -> Ordering {
+    let a = a.segments();
+    let b = b.segments();
+    // cmp_by would be useful for us here but that is currently unstable
+    // cmp doesn't work due the lifetimes on text's return type
+    a.zip(b)
+        .find_map(|(a, b)| match path_segment_cmp(&a, &b) {
+            Ordering::Equal => None,
+            ord => Some(ord),
+        })
+        .unwrap_or(Ordering::Equal)
+}
+/// Compares two paths, if one ends earlier than the other the has_tl parameters decide which is
+/// greater as a a path that has a tree list should be greater, while one that just ends without
+/// a tree list should be considered less.
+pub(super) fn use_tree_path_cmp(
+    a: &ast::Path,
+    a_has_tl: bool,
+    b: &ast::Path,
+    b_has_tl: bool,
+) -> Ordering {
+    let a_segments = a.segments();
+    let b_segments = b.segments();
+    // cmp_by would be useful for us here but that is currently unstable
+    // cmp doesn't work due the lifetimes on text's return type
+    a_segments
+        .zip_longest(b_segments)
+        .find_map(|zipped| match zipped {
+            EitherOrBoth::Both(ref a, ref b) => match path_segment_cmp(a, b) {
+                Ordering::Equal => None,
+                ord => Some(ord),
+            },
+            EitherOrBoth::Left(_) if !b_has_tl => Some(Ordering::Greater),
+            EitherOrBoth::Left(_) => Some(Ordering::Less),
+            EitherOrBoth::Right(_) if !a_has_tl => Some(Ordering::Less),
+            EitherOrBoth::Right(_) => Some(Ordering::Greater),
+        })
+        .unwrap_or(Ordering::Equal)
+}
+fn path_segment_cmp(a: &ast::PathSegment, b: &ast::PathSegment) -> Ordering {
+    let a = a.kind().and_then(|kind| match kind {
+        PathSegmentKind::Name(name_ref) => Some(name_ref),
+        _ => None,
+    });
+    let b = b.kind().and_then(|kind| match kind {
+        PathSegmentKind::Name(name_ref) => Some(name_ref),
+        _ => None,
+    });
+    a.as_ref().map(ast::NameRef::text).cmp(&b.as_ref().map(ast::NameRef::text))
+}
+fn eq_visibility(vis0: Option<ast::Visibility>, vis1: Option<ast::Visibility>) -> bool {
+    match (vis0, vis1) {
+        (None, None) => true,
+        // FIXME: Don't use the string representation to check for equality
+        // spaces inside of the node would break this comparison
+        (Some(vis0), Some(vis1)) => vis0.to_string() == vis1.to_string(),
+        _ => false,
+    }
+}
+fn eq_attrs(
+    attrs0: impl Iterator<Item = ast::Attr>,
+    attrs1: impl Iterator<Item = ast::Attr>,
+) -> bool {
+    let attrs0 = attrs0.map(|attr| attr.to_string());
+    let attrs1 = attrs1.map(|attr| attr.to_string());
+    attrs0.eq(attrs1)
+}
+fn path_is_self(path: &ast::Path) -> bool {
+    path.segment().and_then(|seg| seg.self_token()).is_some() && path.qualifier().is_none()
+}
+fn path_len(path: ast::Path) -> usize {
+    path.segments().count()
+}
diff --git a/crates/ide_db/src/search.rs b/crates/ide_db/src/search.rs
index b55e3851e..8f899ea56 100644
--- a/crates/ide_db/src/search.rs
+++ b/crates/ide_db/src/search.rs
@@ -7,7 +7,9 @@
 use std::{convert::TryInto, mem};
 use base_db::{FileId, FileRange, SourceDatabase, SourceDatabaseExt};
-use hir::{DefWithBody, HasAttrs, HasSource, InFile, ModuleSource, Semantics, Visibility};
+use hir::{
+    DefWithBody, HasAttrs, HasSource, InFile, ModuleDef, ModuleSource, Semantics, Visibility,
+};
 use once_cell::unsync::Lazy;
 use rustc_hash::FxHashMap;
 use syntax::{ast, match_ast, AstNode, TextRange, TextSize};
@@ -295,7 +297,7 @@ impl Definition {
    }
    pub fn usages<'a>(&'a self, sema: &'a Semantics<RootDatabase>) -> FindUsages<'a> {
-        FindUsages { def: self, sema, scope: None }
+        FindUsages { def: self, sema, scope: None, include_self_kw_refs: false }
    }
 }
@@ -303,9 +305,15 @@ pub struct FindUsages<'a> {
    def: &'a Definition,
    sema: &'a Semantics<'a, RootDatabase>,
    scope: Option<SearchScope>,
+    include_self_kw_refs: bool,
 }
 impl<'a> FindUsages<'a> {
+    pub fn include_self_kw_refs(mut self, include: bool) -> FindUsages<'a> {
+        self.include_self_kw_refs = include;
+        self
+    }
    pub fn in_scope(self, scope: SearchScope) -> FindUsages<'a> {
        self.set_scope(Some(scope))
    }
@@ -352,6 +360,8 @@ impl<'a> FindUsages<'a> {
        };
        let pat = name.as_str();
+        let search_for_self = self.include_self_kw_refs;
        for (file_id, search_range) in search_scope {
            let text = sema.db.file_text(file_id);
            let search_range =
@@ -359,31 +369,47 @@ impl<'a> FindUsages<'a> {
            let tree = Lazy::new(|| sema.parse(file_id).syntax().clone());
-            for (idx, _) in text.match_indices(pat) {
+            let mut handle_match = |idx: usize| -> bool {
                let offset: TextSize = idx.try_into().unwrap();
                if !search_range.contains_inclusive(offset) {
-                    continue;
+                    return false;
                }
                if let Some(name) = sema.find_node_at_offset_with_descend(&tree, offset) {
                    match name {
                        ast::NameLike::NameRef(name_ref) => {
                            if self.found_name_ref(&name_ref, sink) {
-                                return;
+                                return true;
                            }
                        }
                        ast::NameLike::Name(name) => {
                            if self.found_name(&name, sink) {
-                                return;
+                                return true;
                            }
                        }
                        ast::NameLike::Lifetime(lifetime) => {
                            if self.found_lifetime(&lifetime, sink) {
-                                return;
+                                return true;
                            }
                        }
                    }
                }
+                return false;
+            };
+            for (idx, _) in text.match_indices(pat) {
+                if handle_match(idx) {
+                    return;
+                }
+            }
+            if search_for_self {
+                for (idx, _) in text.match_indices("Self") {
+                    if handle_match(idx) {
+                        return;
+                    }
+                }
            }
        }
    }
@@ -422,6 +448,24 @@ impl<'a> FindUsages<'a> {
                };
                sink(file_id, reference)
            }
+            Some(NameRefClass::Definition(Definition::SelfType(impl_))) => {
+                let ty = impl_.self_ty(self.sema.db);
+                if let Some(adt) = ty.as_adt() {
+                    if &Definition::ModuleDef(ModuleDef::Adt(adt)) == self.def {
+                        let FileRange { file_id, range } =
+                            self.sema.original_range(name_ref.syntax());
+                        let reference = FileReference {
+                            range,
+                            name: ast::NameLike::NameRef(name_ref.clone()),
+                            access: None,
+                        };
+                        return sink(file_id, reference);
+                    }
+                }
+                false
+            }
            Some(NameRefClass::FieldShorthand { local_ref: local, field_ref: field }) => {
                let FileRange { file_id, range } = self.sema.original_range(name_ref.syntax());
                let reference = match self.def {
diff --git a/crates/project_model/src/build_data.rs b/crates/project_model/src/build_data.rs
index faca336de..7b88dca63 100644
--- a/crates/project_model/src/build_data.rs
+++ b/crates/project_model/src/build_data.rs
@@ -143,7 +143,7 @@ impl WorkspaceBuildData {
            cmd.env("RA_RUSTC_WRAPPER", "1");
        }
-        cmd.args(&["check", "--workspace", "--message-format=json", "--manifest-path"])
+        cmd.args(&["check", "--quiet", "--workspace", "--message-format=json", "--manifest-path"])
            .arg(cargo_toml.as_ref());
        // --all-targets includes tests, benches and examples in addition to the
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index 0571a912c..3e8f4bf89 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -33,7 +33,7 @@ serde_path_to_error = "0.1"
 threadpool = "1.7.1"
 rayon = "1.5"
 mimalloc = { version = "0.1.19", default-features = false, optional = true }
-lsp-server = "0.5.0"
+lsp-server = "0.5.1"
 tracing = "0.1"
 tracing-subscriber = { version = "0.2", default-features = false, features = ["env-filter", "registry"] }
 tracing-tree = { version = "0.1.4" }
diff --git a/crates/rust-analyzer/build.rs b/crates/rust-analyzer/build.rs
index 13b903891..bca6611d6 100644
--- a/crates/rust-analyzer/build.rs
+++ b/crates/rust-analyzer/build.rs
@@ -1,13 +1,10 @@
-//! Just embed git-hash to `--version`
+//! Construct version in the `commit-hash date chanel` format
 use std::{env, path::PathBuf, process::Command};
 fn main() {
    set_rerun();
+    println!("cargo:rustc-env=REV={}", rev())
-    let rev =
-        env::var("RUST_ANALYZER_REV").ok().or_else(rev).unwrap_or_else(|| "???????".to_string());
-    println!("cargo:rustc-env=REV={}", rev)
 }
 fn set_rerun() {
@@ -18,29 +15,52 @@ fn set_rerun() {
    );
    while manifest_dir.parent().is_some() {
-        if manifest_dir.join(".git/HEAD").exists() {
+        let head_ref = manifest_dir.join(".git/HEAD");
-            let git_dir = manifest_dir.join(".git");
+        if head_ref.exists() {
+            println!("cargo:rerun-if-changed={}", head_ref.display());
-            println!("cargo:rerun-if-changed={}", git_dir.join("HEAD").display());
-            // current branch ref
-            if let Ok(output) =
-                Command::new("git").args(&["rev-parse", "--symbolic-full-name", "HEAD"]).output()
-            {
-                if let Ok(ref_link) = String::from_utf8(output.stdout) {
-                    println!("cargo:rerun-if-changed={}", git_dir.join(ref_link).display());
-                }
-            }
            return;
        }
        manifest_dir.pop();
    }
    println!("cargo:warning=Could not find `.git/HEAD` from manifest dir!");
 }
-fn rev() -> Option<String> {
+fn rev() -> String {
-    let output =
+    if let Ok(rev) = env::var("RUST_ANALYZER_REV") {
-        Command::new("git").args(&["describe", "--tags", "--exclude", "nightly"]).output().ok()?;
+        return rev;
+    }
+    if let Some(commit_hash) = commit_hash() {
+        let mut buf = commit_hash;
+        if let Some(date) = build_date() {
+            buf.push(' ');
+            buf.push_str(&date);
+        }
+        let channel = env::var("RUST_ANALYZER_CHANNEL").unwrap_or_else(|_| "dev".to_string());
+        buf.push(' ');
+        buf.push_str(&channel);
+        return buf;
+    }
+    "???????".to_string()
+}
+fn commit_hash() -> Option<String> {
+    output_to_string("git rev-parse --short HEAD")
+}
+fn build_date() -> Option<String> {
+    output_to_string("date -u +%Y-%m-%d")
+}
+fn output_to_string(command: &str) -> Option<String> {
+    let args = command.split_ascii_whitespace().collect::<Vec<_>>();
+    let output = Command::new(args[0]).args(&args[1..]).output().ok()?;
    let stdout = String::from_utf8(output.stdout).ok()?;
-    Some(stdout)
+    Some(stdout.trim().to_string())
 }
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 1109d2daf..28bbbce19 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -12,7 +12,8 @@ use std::{ffi::OsString, iter, path::PathBuf};
 use flycheck::FlycheckConfig;
 use ide::{AssistConfig, CompletionConfig, DiagnosticsConfig, HoverConfig, InlayHintsConfig};
 use ide_db::helpers::{
-    insert_use::{InsertUseConfig, MergeBehavior, PrefixKind},
+    insert_use::{InsertUseConfig, PrefixKind},
+    merge_imports::MergeBehavior,
    SnippetCap,
 };
 use lsp_types::{ClientCapabilities, MarkupKind};
@@ -144,6 +145,8 @@ config_data! {
        inlayHints_parameterHints: bool     = "true",
        /// Whether to show inlay type hints for variables.
        inlayHints_typeHints: bool          = "true",
+        /// Whether inlay hints font size should be smaller than editor's font size.
+        inlayHints_smallerHints: bool       = "true",
        /// Whether to show `Debug` lens. Only applies when
        /// `#rust-analyzer.lens.enable#` is set.
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 6ea775d68..a766aacad 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -571,6 +571,12 @@ impl GlobalState {
                this.cancel(id);
                Ok(())
            })?
+            .on::<lsp_types::notification::WorkDoneProgressCancel>(|_this, _params| {
+                // Just ignore this. It is OK to continue sending progress
+                // notifications for this token, as the client can't know when
+                // we accepted notification.
+                Ok(())
+            })?
            .on::<lsp_types::notification::DidOpenTextDocument>(|this, params| {
                if let Ok(path) = from_proto::vfs_path(&params.text_document.uri) {
                    if this
diff --git a/crates/stdx/src/lib.rs b/crates/stdx/src/lib.rs
index 857567a85..1b6211044 100644
--- a/crates/stdx/src/lib.rs
+++ b/crates/stdx/src/lib.rs
@@ -14,18 +14,8 @@ pub fn is_ci() -> bool {
 #[must_use]
 pub fn timeit(label: &'static str) -> impl Drop {
-    struct Guard {
+    let start = Instant::now();
-        label: &'static str,
+    defer(move || eprintln!("{}: {:.2?}", label, start.elapsed()))
-        start: Instant,
-    }
-    impl Drop for Guard {
-        fn drop(&mut self) {
-            eprintln!("{}: {:.2?}", self.label, self.start.elapsed())
-        }
-    }
-    Guard { label, start: Instant::now() }
 }
 /// Prints backtrace to stderr, useful for debugging.
@@ -179,6 +169,7 @@ where
    start..start + len
 }
+#[must_use]
 pub fn defer<F: FnOnce()>(f: F) -> impl Drop {
    struct D<F: FnOnce()>(Option<F>);
    impl<F: FnOnce()> Drop for D<F> {
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> {
+impl SyntaxRewriter<'_> {
-    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(),
-        }
-    }
    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/make.rs b/crates/syntax/src/ast/make.rs
index 4cf6f871e..42da09606 100644
--- a/crates/syntax/src/ast/make.rs
+++ b/crates/syntax/src/ast/make.rs
@@ -137,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)),
@@ -339,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());
@@ -606,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 171099661..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;
@@ -237,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 450f2e447..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)
@@ -173,7 +183,10 @@ fn ws_between(left: &SyntaxElement, right: &SyntaxElement) -> Option<SyntaxToken
    }
    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/docs/user/generated_config.adoc b/docs/user/generated_config.adoc
index e28423e99..db3c5f7bb 100644
--- a/docs/user/generated_config.adoc
+++ b/docs/user/generated_config.adoc
@@ -234,6 +234,11 @@ site.
 --
 Whether to show inlay type hints for variables.
 --
+[[rust-analyzer.inlayHints.smallerHints]]rust-analyzer.inlayHints.smallerHints (default: `true`)::
+
+--
+Whether inlay hints font size should be smaller than editor's font size.
+--
 [[rust-analyzer.lens.debug]]rust-analyzer.lens.debug (default: `true`)::
 +
 --
diff --git a/editors/code/package-lock.json b/editors/code/package-lock.json
index 198c17556..df0c512d6 100644
--- a/editors/code/package-lock.json
+++ b/editors/code/package-lock.json
@@ -53,9 +53,9 @@
            "dev": true
        },
        "node_modules/@babel/highlight": {
-            "version": "7.12.13",
+            "version": "7.13.10",
-            "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.12.13.tgz",
+            "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.13.10.tgz",
-            "integrity": "sha512-kocDQvIbgMKlWxXe9fof3TQ+gkIPOUSEYhJjqUjvKMez3krV7vbzYCDq39Oj11UAVK7JqPVGQPlgE85dPNlQww==",
+            "integrity": "sha512-5aPpe5XQPzflQrFwL1/QoeHkP2MsA4JCntcXHRhEsdsfPVkvPi2w7Qix4iV7t5S/oC9OodGrggd8aco1g3SZFg==",
            "dev": true,
            "dependencies": {
                "@babel/helper-validator-identifier": "^7.12.11",
@@ -135,9 +135,9 @@
            }
        },
        "node_modules/@eslint/eslintrc": {
-            "version": "0.3.0",
+            "version": "0.4.0",
-            "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-0.3.0.tgz",
+            "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-0.4.0.tgz",
-            "integrity": "sha512-1JTKgrOKAHVivSvOYw+sJOunkBjUOvjqWk1DPja7ZFhIS2mX/4EgTT8M7eTK9jrKhL/FvXXEbQwIs3pg1xp3dg==",
+            "integrity": "sha512-2ZPCc+uNbjV5ERJr+aKSPRwZgKd2z11x0EgLvb1PURmUrn9QNRXFqje0Ldq454PfAVyaJYyrDvvIKSFP4NnBog==",
            "dev": true,
            "dependencies": {
                "ajv": "^6.12.4",
@@ -147,7 +147,6 @@
                "ignore": "^4.0.6",
                "import-fresh": "^3.2.1",
                "js-yaml": "^3.13.1",
-                "lodash": "^4.17.20",
                "minimatch": "^3.0.4",
                "strip-json-comments": "^3.1.1"
            },
@@ -155,6 +154,30 @@
                "node": "^10.12.0 || >=12.0.0"
            }
        },
+        "node_modules/@eslint/eslintrc/node_modules/globals": {
+            "version": "12.4.0",
+            "resolved": "https://registry.npmjs.org/globals/-/globals-12.4.0.tgz",
+            "integrity": "sha512-BWICuzzDvDoH54NHKCseDanAhE3CeDorgDL5MT6LMXXj2WCnd9UC2szdk4AWLfjdgNBCXLUanXYcpBBKOSWGwg==",
+            "dev": true,
+            "dependencies": {
+                "type-fest": "^0.8.1"
+            },
+            "engines": {
+                "node": ">=8"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
+        "node_modules/@eslint/eslintrc/node_modules/type-fest": {
+            "version": "0.8.1",
+            "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.8.1.tgz",
+            "integrity": "sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==",
+            "dev": true,
+            "engines": {
+                "node": ">=8"
+            }
+        },
        "node_modules/@nodelib/fs.scandir": {
            "version": "2.1.4",
            "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.4.tgz",
@@ -212,9 +235,9 @@
            }
        },
        "node_modules/@rollup/plugin-node-resolve": {
-            "version": "11.2.0",
+            "version": "11.2.1",
-            "resolved": "https://registry.npmjs.org/@rollup/plugin-node-resolve/-/plugin-node-resolve-11.2.0.tgz",
+            "resolved": "https://registry.npmjs.org/@rollup/plugin-node-resolve/-/plugin-node-resolve-11.2.1.tgz",
-            "integrity": "sha512-qHjNIKYt5pCcn+5RUBQxK8krhRvf1HnyVgUCcFFcweDS7fhkOLZeYh0mhHK6Ery8/bb9tvN/ubPzmfF0qjDCTA==",
+            "integrity": "sha512-yc2n43jcqVyGE2sqV5/YCmocy9ArjVAP/BeXyTtADTBBX6V0e5UMqwO8CdQ0kzjb6zu5P1qMzsScCMRvE9OlVg==",
            "dev": true,
            "dependencies": {
                "@rollup/pluginutils": "^3.1.0",
@@ -286,15 +309,15 @@
            "dev": true
        },
        "node_modules/@types/minimatch": {
-            "version": "3.0.3",
+            "version": "3.0.4",
-            "resolved": "https://registry.npmjs.org/@types/minimatch/-/minimatch-3.0.3.tgz",
+            "resolved": "https://registry.npmjs.org/@types/minimatch/-/minimatch-3.0.4.tgz",
-            "integrity": "sha512-tHq6qdbT9U1IRSGf14CL0pUlULksvY9OZ+5eEgl1N7t+OA3tGvNpxJCzuKQlsNgCVwbAs670L1vcVQi8j9HjnA==",
+            "integrity": "sha512-1z8k4wzFnNjVK/tlxvrWuK5WMt6mydWWP7+zvH5eFep4oj+UkrfiJTRtjCeBXNpwaA/FYqqtb4/QS4ianFpIRA==",
            "dev": true
        },
        "node_modules/@types/mocha": {
-            "version": "8.2.1",
+            "version": "8.2.2",
-            "resolved": "https://registry.npmjs.org/@types/mocha/-/mocha-8.2.1.tgz",
+            "resolved": "https://registry.npmjs.org/@types/mocha/-/mocha-8.2.2.tgz",
-            "integrity": "sha512-NysN+bNqj6E0Hv4CTGWSlPzMW6vTKjDpOteycDkV4IWBsO+PU48JonrPzV9ODjiI2XrjmA05KInLgF5ivZ/YGQ==",
+            "integrity": "sha512-Lwh0lzzqT5Pqh6z61P3c3P5nm6fzQK/MMHl9UKeneAeInVflBSz1O2EkX6gM6xfJd7FBXBY5purtLx7fUiZ7Hw==",
            "dev": true
        },
        "node_modules/@types/node": {
@@ -304,9 +327,9 @@
            "dev": true
        },
        "node_modules/@types/node-fetch": {
-            "version": "2.5.8",
+            "version": "2.5.10",
-            "resolved": "https://registry.npmjs.org/@types/node-fetch/-/node-fetch-2.5.8.tgz",
+            "resolved": "https://registry.npmjs.org/@types/node-fetch/-/node-fetch-2.5.10.tgz",
-            "integrity": "sha512-fbjI6ja0N5ZA8TV53RUqzsKNkl9fv8Oj3T7zxW7FGv1GSH7gwJaNF8dzCjrqKaxKeUpTz4yT1DaJFq/omNpGfw==",
+            "integrity": "sha512-IpkX0AasN44hgEad0gEF/V6EgR5n69VEqPEgnmoM8GsIGro3PowbWs4tR6IhxUTyPLpOn+fiGG6nrQhcmoCuIQ==",
            "dev": true,
            "dependencies": {
                "@types/node": "*",
@@ -323,19 +346,19 @@
            }
        },
        "node_modules/@types/vscode": {
-            "version": "1.53.0",
+            "version": "1.55.0",
-            "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.53.0.tgz",
+            "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.55.0.tgz",
-            "integrity": "sha512-XjFWbSPOM0EKIT2XhhYm3D3cx3nn3lshMUcWNy1eqefk+oqRuBq8unVb6BYIZqXy9lQZyeUl7eaBCOZWv+LcXQ==",
+            "integrity": "sha512-49hysH7jneTQoSC8TWbAi7nKK9Lc5osQNjmDHVosrcU8o3jecD9GrK0Qyul8q4aGPSXRfNGqIp9CBdb13akETg==",
            "dev": true
        },
        "node_modules/@typescript-eslint/eslint-plugin": {
-            "version": "4.15.2",
+            "version": "4.22.0",
-            "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-4.15.2.tgz",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-4.22.0.tgz",
-            "integrity": "sha512-uiQQeu9tWl3f1+oK0yoAv9lt/KXO24iafxgQTkIYO/kitruILGx3uH+QtIAHqxFV+yIsdnJH+alel9KuE3J15Q==",
+            "integrity": "sha512-U8SP9VOs275iDXaL08Ln1Fa/wLXfj5aTr/1c0t0j6CdbOnxh+TruXu1p4I0NAvdPBQgoPjHsgKn28mOi0FzfoA==",
            "dev": true,
            "dependencies": {
-                "@typescript-eslint/experimental-utils": "4.15.2",
+                "@typescript-eslint/experimental-utils": "4.22.0",
-                "@typescript-eslint/scope-manager": "4.15.2",
+                "@typescript-eslint/scope-manager": "4.22.0",
                "debug": "^4.1.1",
                "functional-red-black-tree": "^1.0.1",
                "lodash": "^4.17.15",
@@ -361,15 +384,15 @@
            }
        },
        "node_modules/@typescript-eslint/experimental-utils": {
-            "version": "4.15.2",
+            "version": "4.22.0",
-            "resolved": "https://registry.npmjs.org/@typescript-eslint/experimental-utils/-/experimental-utils-4.15.2.tgz",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/experimental-utils/-/experimental-utils-4.22.0.tgz",
-            "integrity": "sha512-Fxoshw8+R5X3/Vmqwsjc8nRO/7iTysRtDqx6rlfLZ7HbT8TZhPeQqbPjTyk2RheH3L8afumecTQnUc9EeXxohQ==",
+            "integrity": "sha512-xJXHHl6TuAxB5AWiVrGhvbGL8/hbiCQ8FiWwObO3r0fnvBdrbWEDy1hlvGQOAWc6qsCWuWMKdVWlLAEMpxnddg==",
            "dev": true,
            "dependencies": {
                "@types/json-schema": "^7.0.3",
-                "@typescript-eslint/scope-manager": "4.15.2",
+                "@typescript-eslint/scope-manager": "4.22.0",
-                "@typescript-eslint/types": "4.15.2",
+                "@typescript-eslint/types": "4.22.0",
-                "@typescript-eslint/typescript-estree": "4.15.2",
+                "@typescript-eslint/typescript-estree": "4.22.0",
                "eslint-scope": "^5.0.0",
                "eslint-utils": "^2.0.0"
            },
@@ -385,14 +408,14 @@
            }
        },
        "node_modules/@typescript-eslint/parser": {
-            "version": "4.15.2",
+            "version": "4.22.0",
-            "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-4.15.2.tgz",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-4.22.0.tgz",
-            "integrity": "sha512-SHeF8xbsC6z2FKXsaTb1tBCf0QZsjJ94H6Bo51Y1aVEZ4XAefaw5ZAilMoDPlGghe+qtq7XdTiDlGfVTOmvA+Q==",
+            "integrity": "sha512-z/bGdBJJZJN76nvAY9DkJANYgK3nlRstRRi74WHm3jjgf2I8AglrSY+6l7ogxOmn55YJ6oKZCLLy+6PW70z15Q==",
            "dev": true,
            "dependencies": {
-                "@typescript-eslint/scope-manager": "4.15.2",
+                "@typescript-eslint/scope-manager": "4.22.0",
-                "@typescript-eslint/types": "4.15.2",
+                "@typescript-eslint/types": "4.22.0",
-                "@typescript-eslint/typescript-estree": "4.15.2",
+                "@typescript-eslint/typescript-estree": "4.22.0",
                "debug": "^4.1.1"
            },
            "engines": {
@@ -412,13 +435,13 @@
            }
        },
        "node_modules/@typescript-eslint/scope-manager": {
-            "version": "4.15.2",
+            "version": "4.22.0",
-            "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-4.15.2.tgz",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-4.22.0.tgz",
-            "integrity": "sha512-Zm0tf/MSKuX6aeJmuXexgdVyxT9/oJJhaCkijv0DvJVT3ui4zY6XYd6iwIo/8GEZGy43cd7w1rFMiCLHbRzAPQ==",
+            "integrity": "sha512-OcCO7LTdk6ukawUM40wo61WdeoA7NM/zaoq1/2cs13M7GyiF+T4rxuA4xM+6LeHWjWbss7hkGXjFDRcKD4O04Q==",
            "dev": true,
            "dependencies": {
-                "@typescript-eslint/types": "4.15.2",
+                "@typescript-eslint/types": "4.22.0",
-                "@typescript-eslint/visitor-keys": "4.15.2"
+                "@typescript-eslint/visitor-keys": "4.22.0"
            },
            "engines": {
                "node": "^8.10.0 || ^10.13.0 || >=11.10.1"
@@ -429,9 +452,9 @@
            }
        },
        "node_modules/@typescript-eslint/types": {
-            "version": "4.15.2",
+            "version": "4.22.0",
-            "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-4.15.2.tgz",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-4.22.0.tgz",
-            "integrity": "sha512-r7lW7HFkAarfUylJ2tKndyO9njwSyoy6cpfDKWPX6/ctZA+QyaYscAHXVAfJqtnY6aaTwDYrOhp+ginlbc7HfQ==",
+            "integrity": "sha512-sW/BiXmmyMqDPO2kpOhSy2Py5w6KvRRsKZnV0c4+0nr4GIcedJwXAq+RHNK4lLVEZAJYFltnnk1tJSlbeS9lYA==",
            "dev": true,
            "engines": {
                "node": "^8.10.0 || ^10.13.0 || >=11.10.1"
@@ -442,13 +465,13 @@
            }
        },
        "node_modules/@typescript-eslint/typescript-estree": {
-            "version": "4.15.2",
+            "version": "4.22.0",
-            "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-4.15.2.tgz",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-4.22.0.tgz",
-            "integrity": "sha512-cGR8C2g5SPtHTQvAymEODeqx90pJHadWsgTtx6GbnTWKqsg7yp6Eaya9nFzUd4KrKhxdYTTFBiYeTPQaz/l8bw==",
+            "integrity": "sha512-TkIFeu5JEeSs5ze/4NID+PIcVjgoU3cUQUIZnH3Sb1cEn1lBo7StSV5bwPuJQuoxKXlzAObjYTilOEKRuhR5yg==",
            "dev": true,
            "dependencies": {
-                "@typescript-eslint/types": "4.15.2",
+                "@typescript-eslint/types": "4.22.0",
-                "@typescript-eslint/visitor-keys": "4.15.2",
+                "@typescript-eslint/visitor-keys": "4.22.0",
                "debug": "^4.1.1",
                "globby": "^11.0.1",
                "is-glob": "^4.0.1",
@@ -469,12 +492,12 @@
            }
        },
        "node_modules/@typescript-eslint/visitor-keys": {
-            "version": "4.15.2",
+            "version": "4.22.0",
-            "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-4.15.2.tgz",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-4.22.0.tgz",
-            "integrity": "sha512-TME1VgSb7wTwgENN5KVj4Nqg25hP8DisXxNBojM4Nn31rYaNDIocNm5cmjOFfh42n7NVERxWrDFoETO/76ePyg==",
+            "integrity": "sha512-nnMu4F+s4o0sll6cBSsTeVsT4cwxB7zECK3dFxzEjPBii9xLpq4yqqsy/FU5zMfan6G60DKZSCXAa3sHJZrcYw==",
            "dev": true,
            "dependencies": {
-                "@typescript-eslint/types": "4.15.2",
+                "@typescript-eslint/types": "4.22.0",
                "eslint-visitor-keys": "^2.0.0"
            },
            "engines": {
@@ -573,9 +596,9 @@
            }
        },
        "node_modules/anymatch": {
-            "version": "3.1.1",
+            "version": "3.1.2",
-            "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.1.tgz",
+            "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.2.tgz",
-            "integrity": "sha512-mM8522psRCqzV+6LhomX5wgp25YVibjh8Wj23I5RPkPppSVSjyKD2A2mBJmWGa+KN7f2D6LNh9jkBCeyLktzjg==",
+            "integrity": "sha512-P43ePfOAIupkguHUycrc4qJ9kz8ZiuOUijaETwX7THt0Y/GNK7v0aa8rY816xWjZ7rJdA5XdMcpVFTKMq+RvWg==",
            "dev": true,
            "dependencies": {
                "normalize-path": "^3.0.0",
@@ -631,9 +654,9 @@
            }
        },
        "node_modules/balanced-match": {
-            "version": "1.0.0",
+            "version": "1.0.2",
-            "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz",
+            "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
-            "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c="
+            "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="
        },
        "node_modules/big-integer": {
            "version": "1.6.48",
@@ -772,9 +795,9 @@
            }
        },
        "node_modules/chalk": {
-            "version": "4.1.0",
+            "version": "4.1.1",
-            "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.0.tgz",
+            "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.1.tgz",
-            "integrity": "sha512-qwx12AxXe2Q5xQ43Ac//I6v5aXTipYrSESdOgzrN+9XjgEpyjpKuvSGaN4qE93f7TQTlerQQ8S+EQ0EyDoVL1A==",
+            "integrity": "sha512-diHzdDKxcU+bAsUboHLPEDQiw0qEe0qd7SYUn3HgcFlWgbDcfLGswOHYeGrHKzG9z6UYf01d9VFMfZxPM1xZSg==",
            "dev": true,
            "dependencies": {
                "ansi-styles": "^4.1.0",
@@ -788,35 +811,33 @@
            }
        },
        "node_modules/cheerio": {
-            "version": "1.0.0-rc.5",
+            "version": "1.0.0-rc.6",
-            "resolved": "https://registry.npmjs.org/cheerio/-/cheerio-1.0.0-rc.5.tgz",
+            "resolved": "https://registry.npmjs.org/cheerio/-/cheerio-1.0.0-rc.6.tgz",
-            "integrity": "sha512-yoqps/VCaZgN4pfXtenwHROTp8NG6/Hlt4Jpz2FEP0ZJQ+ZUkVDd0hAPDNKhj3nakpfPt/CNs57yEtxD1bXQiw==",
+            "integrity": "sha512-hjx1XE1M/D5pAtMgvWwE21QClmAEeGHOIDfycgmndisdNgI6PE1cGRQkMGBcsbUbmEQyWu5PJLUcAOjtQS8DWw==",
            "dev": true,
            "dependencies": {
-                "cheerio-select-tmp": "^0.1.0",
+                "cheerio-select": "^1.3.0",
-                "dom-serializer": "~1.2.0",
+                "dom-serializer": "^1.3.1",
-                "domhandler": "^4.0.0",
+                "domhandler": "^4.1.0",
-                "entities": "~2.1.0",
+                "htmlparser2": "^6.1.0",
-                "htmlparser2": "^6.0.0",
+                "parse5": "^6.0.1",
-                "parse5": "^6.0.0",
+                "parse5-htmlparser2-tree-adapter": "^6.0.1"
-                "parse5-htmlparser2-tree-adapter": "^6.0.0"
            },
            "engines": {
                "node": ">= 0.12"
            }
        },
-        "node_modules/cheerio-select-tmp": {
+        "node_modules/cheerio-select": {
-            "version": "0.1.1",
+            "version": "1.4.0",
-            "resolved": "https://registry.npmjs.org/cheerio-select-tmp/-/cheerio-select-tmp-0.1.1.tgz",
+            "resolved": "https://registry.npmjs.org/cheerio-select/-/cheerio-select-1.4.0.tgz",
-            "integrity": "sha512-YYs5JvbpU19VYJyj+F7oYrIE2BOll1/hRU7rEy/5+v9BzkSo3bK81iAeeQEMI92vRIxz677m72UmJUiVwwgjfQ==",
+            "integrity": "sha512-sobR3Yqz27L553Qa7cK6rtJlMDbiKPdNywtR95Sj/YgfpLfy0u6CGJuaBKe5YE/vTc23SCRKxWSdlon/w6I/Ew==",
-            "deprecated": "Use cheerio-select instead",
            "dev": true,
            "dependencies": {
-                "css-select": "^3.1.2",
+                "css-select": "^4.1.2",
-                "css-what": "^4.0.0",
+                "css-what": "^5.0.0",
-                "domelementtype": "^2.1.0",
+                "domelementtype": "^2.2.0",
-                "domhandler": "^4.0.0",
+                "domhandler": "^4.2.0",
-                "domutils": "^2.4.4"
+                "domutils": "^2.6.0"
            },
            "funding": {
                "url": "https://github.com/sponsors/fb55"
@@ -830,7 +851,6 @@
            "dependencies": {
                "anymatch": "~3.1.1",
                "braces": "~3.0.2",
-                "fsevents": "~2.3.1",
                "glob-parent": "~5.1.0",
                "is-binary-path": "~2.1.0",
                "is-glob": "~4.0.1",
@@ -929,15 +949,15 @@
            }
        },
        "node_modules/css-select": {
-            "version": "3.1.2",
+            "version": "4.1.2",
-            "resolved": "https://registry.npmjs.org/css-select/-/css-select-3.1.2.tgz",
+            "resolved": "https://registry.npmjs.org/css-select/-/css-select-4.1.2.tgz",
-            "integrity": "sha512-qmss1EihSuBNWNNhHjxzxSfJoFBM/lERB/Q4EnsJQQC62R2evJDW481091oAdOr9uh46/0n4nrg0It5cAnj1RA==",
+            "integrity": "sha512-nu5ye2Hg/4ISq4XqdLY2bEatAcLIdt3OYGFc9Tm9n7VSlFBcfRv0gBNksHRgSdUDQGtN3XrZ94ztW+NfzkFSUw==",
            "dev": true,
            "dependencies": {
                "boolbase": "^1.0.0",
-                "css-what": "^4.0.0",
+                "css-what": "^5.0.0",
-                "domhandler": "^4.0.0",
+                "domhandler": "^4.2.0",
-                "domutils": "^2.4.3",
+                "domutils": "^2.6.0",
                "nth-check": "^2.0.0"
            },
            "funding": {
@@ -945,9 +965,9 @@
            }
        },
        "node_modules/css-what": {
-            "version": "4.0.0",
+            "version": "5.0.0",
-            "resolved": "https://registry.npmjs.org/css-what/-/css-what-4.0.0.tgz",
+            "resolved": "https://registry.npmjs.org/css-what/-/css-what-5.0.0.tgz",
-            "integrity": "sha512-teijzG7kwYfNVsUh2H/YN62xW3KK9YhXEgSlbxMlcyjPNvdKJqFx5lrwlJgoFP1ZHlB89iGDlo/JyshKeRhv5A==",
+            "integrity": "sha512-qxyKHQvgKwzwDWC/rGbT821eJalfupxYW2qbSJSAtdSTimsr/MlaGONoNLllaUPZWf8QnbcKM/kPVYUQuEKAFA==",
            "dev": true,
            "engines": {
                "node": ">= 6"
@@ -1048,9 +1068,9 @@
            }
        },
        "node_modules/dom-serializer": {
-            "version": "1.2.0",
+            "version": "1.3.1",
-            "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-1.2.0.tgz",
+            "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-1.3.1.tgz",
-            "integrity": "sha512-n6kZFH/KlCrqs/1GHMOd5i2fd/beQHuehKdWvNNffbGHTr/almdhuVvTVFb3V7fglz+nC50fFusu3lY33h12pA==",
+            "integrity": "sha512-Pv2ZluG5ife96udGgEDovOOOA5UELkltfJpnIExPrAk1LTvecolUGn6lIaoLh86d83GiB86CjzciMd9BuRB71Q==",
            "dev": true,
            "dependencies": {
                "domelementtype": "^2.0.1",
@@ -1062,9 +1082,9 @@
            }
        },
        "node_modules/domelementtype": {
-            "version": "2.1.0",
+            "version": "2.2.0",
-            "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-2.1.0.tgz",
+            "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-2.2.0.tgz",
-            "integrity": "sha512-LsTgx/L5VpD+Q8lmsXSHW2WpA+eBlZ9HPf3erD1IoPF00/3JKHZ3BknUVA2QGDNu69ZNmyFmCWBSO45XjYKC5w==",
+            "integrity": "sha512-DtBMo82pv1dFtUmHyr48beiuq792Sxohr+8Hm9zoxklYPfa6n0Z3Byjj2IV7bmr2IyqClnqEQhfgHJJ5QF0R5A==",
            "dev": true,
            "funding": [
                {
@@ -1074,12 +1094,12 @@
            ]
        },
        "node_modules/domhandler": {
-            "version": "4.0.0",
+            "version": "4.2.0",
-            "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-4.0.0.tgz",
+            "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-4.2.0.tgz",
-            "integrity": "sha512-KPTbnGQ1JeEMQyO1iYXoagsI6so/C96HZiFyByU3T6iAzpXn8EGEvct6unm1ZGoed8ByO2oirxgwxBmqKF9haA==",
+            "integrity": "sha512-zk7sgt970kzPks2Bf+dwT/PLzghLnsivb9CcxkvR8Mzr66Olr0Ofd8neSbglHJHaHa2MadfoSdNlKYAaafmWfA==",
            "dev": true,
            "dependencies": {
-                "domelementtype": "^2.1.0"
+                "domelementtype": "^2.2.0"
            },
            "engines": {
                "node": ">= 4"
@@ -1089,14 +1109,14 @@
            }
        },
        "node_modules/domutils": {
-            "version": "2.4.4",
+            "version": "2.6.0",
-            "resolved": "https://registry.npmjs.org/domutils/-/domutils-2.4.4.tgz",
+            "resolved": "https://registry.npmjs.org/domutils/-/domutils-2.6.0.tgz",
-            "integrity": "sha512-jBC0vOsECI4OMdD0GC9mGn7NXPLb+Qt6KW1YDQzeQYRUFKmNG8lh7mO5HiELfr+lLQE7loDVI4QcAxV80HS+RA==",
+            "integrity": "sha512-y0BezHuy4MDYxh6OvolXYsH+1EMGmFbwv5FKW7ovwMG6zTPWqNPq3WF9ayZssFq+UlKdffGLbOEaghNdaOm1WA==",
            "dev": true,
            "dependencies": {
                "dom-serializer": "^1.0.1",
-                "domelementtype": "^2.0.1",
+                "domelementtype": "^2.2.0",
-                "domhandler": "^4.0.0"
+                "domhandler": "^4.2.0"
            },
            "funding": {
                "url": "https://github.com/fb55/domutils?sponsor=1"
@@ -1167,9 +1187,9 @@
            }
        },
        "node_modules/entities": {
-            "version": "2.1.0",
+            "version": "2.2.0",
-            "resolved": "https://registry.npmjs.org/entities/-/entities-2.1.0.tgz",
+            "resolved": "https://registry.npmjs.org/entities/-/entities-2.2.0.tgz",
-            "integrity": "sha512-hCx1oky9PFrJ611mf0ifBLBRW8lUUVRlFolb5gWRfIELabBlbp9xZvrqZLZAs+NxFnbfQoeGd8wDkygjg7U85w==",
+            "integrity": "sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A==",
            "dev": true,
            "funding": {
                "url": "https://github.com/fb55/entities?sponsor=1"
@@ -1197,13 +1217,13 @@
            }
        },
        "node_modules/eslint": {
-            "version": "7.20.0",
+            "version": "7.25.0",
-            "resolved": "https://registry.npmjs.org/eslint/-/eslint-7.20.0.tgz",
+            "resolved": "https://registry.npmjs.org/eslint/-/eslint-7.25.0.tgz",
-            "integrity": "sha512-qGi0CTcOGP2OtCQBgWZlQjcTuP0XkIpYFj25XtRTQSHC+umNnp7UMshr2G8SLsRFYDdAPFeHOsiteadmMH02Yw==",
+            "integrity": "sha512-TVpSovpvCNpLURIScDRB6g5CYu/ZFq9GfX2hLNIV4dSBKxIWojeDODvYl3t0k0VtMxYeR8OXPCFE5+oHMlGfhw==",
            "dev": true,
            "dependencies": {
                "@babel/code-frame": "7.12.11",
-                "@eslint/eslintrc": "^0.3.0",
+                "@eslint/eslintrc": "^0.4.0",
                "ajv": "^6.10.0",
                "chalk": "^4.0.0",
                "cross-spawn": "^7.0.2",
@@ -1216,10 +1236,10 @@
                "espree": "^7.3.1",
                "esquery": "^1.4.0",
                "esutils": "^2.0.2",
-                "file-entry-cache": "^6.0.0",
+                "file-entry-cache": "^6.0.1",
                "functional-red-black-tree": "^1.0.1",
                "glob-parent": "^5.0.0",
-                "globals": "^12.1.0",
+                "globals": "^13.6.0",
                "ignore": "^4.0.6",
                "import-fresh": "^3.0.0",
                "imurmurhash": "^0.1.4",
@@ -1227,7 +1247,7 @@
                "js-yaml": "^3.13.1",
                "json-stable-stringify-without-jsonify": "^1.0.1",
                "levn": "^0.4.1",
-                "lodash": "^4.17.20",
+                "lodash": "^4.17.21",
                "minimatch": "^3.0.4",
                "natural-compare": "^1.4.0",
                "optionator": "^0.9.1",
@@ -1434,9 +1454,9 @@
            "dev": true
        },
        "node_modules/fastq": {
-            "version": "1.10.1",
+            "version": "1.11.0",
-            "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.10.1.tgz",
+            "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.11.0.tgz",
-            "integrity": "sha512-AWuv6Ery3pM+dY7LYS8YIaCiQvUaos9OB1RyNgaOWnaX+Tik7Onvcsf8x8c+YtDeT0maYLniBip2hox5KtEXXA==",
+            "integrity": "sha512-7Eczs8gIPDrVzT+EksYBcupqMyxSHXXrHOLRRxU2/DicV8789MRBRR8+Hc2uWzUupOs4YS4JzBmBxjjCVBxD/g==",
            "dev": true,
            "dependencies": {
                "reusify": "^1.0.4"
@@ -1622,9 +1642,9 @@
            }
        },
        "node_modules/glob-parent": {
-            "version": "5.1.1",
+            "version": "5.1.2",
-            "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.1.tgz",
+            "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
-            "integrity": "sha512-FnI+VGOpnlGHWZxthPGR+QhR78fuiK0sNLkHQv+bL9fQi57lNNdquIbna/WrfROrolq8GK5Ek6BiMwqL/voRYQ==",
+            "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
            "dev": true,
            "dependencies": {
                "is-glob": "^4.0.1"
@@ -1634,12 +1654,12 @@
            }
        },
        "node_modules/globals": {
-            "version": "12.4.0",
+            "version": "13.8.0",
-            "resolved": "https://registry.npmjs.org/globals/-/globals-12.4.0.tgz",
+            "resolved": "https://registry.npmjs.org/globals/-/globals-13.8.0.tgz",
-            "integrity": "sha512-BWICuzzDvDoH54NHKCseDanAhE3CeDorgDL5MT6LMXXj2WCnd9UC2szdk4AWLfjdgNBCXLUanXYcpBBKOSWGwg==",
+            "integrity": "sha512-rHtdA6+PDBIjeEvA91rpqzEvk/k3/i7EeNQiryiWuJH0Hw9cpyJMAt2jtbAwUaRdhD+573X4vWw6IcjKPasi9Q==",
            "dev": true,
            "dependencies": {
-                "type-fest": "^0.8.1"
+                "type-fest": "^0.20.2"
            },
            "engines": {
                "node": ">=8"
@@ -1649,9 +1669,9 @@
            }
        },
        "node_modules/globby": {
-            "version": "11.0.2",
+            "version": "11.0.3",
-            "resolved": "https://registry.npmjs.org/globby/-/globby-11.0.2.tgz",
+            "resolved": "https://registry.npmjs.org/globby/-/globby-11.0.3.tgz",
-            "integrity": "sha512-2ZThXDvvV8fYFRVIxnrMQBipZQDr7MxKAmQK1vujaj9/7eF0efG7BPUKJ7jP7G5SLF37xKDXvO4S/KKLj/Z0og==",
+            "integrity": "sha512-ffdmosjA807y7+lA1NM0jELARVmYul/715xiILEjo3hBLPTcirgQNnXECn5g3mtR8TOLCVbkfua1Hpen25/Xcg==",
            "dev": true,
            "dependencies": {
                "array-union": "^2.1.0",
@@ -1723,9 +1743,9 @@
            }
        },
        "node_modules/htmlparser2": {
-            "version": "6.0.0",
+            "version": "6.1.0",
-            "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-6.0.0.tgz",
+            "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-6.1.0.tgz",
-            "integrity": "sha512-numTQtDZMoh78zJpaNdJ9MXb2cv5G3jwUoe3dMQODubZvLoGvTE/Ofp6sHvH8OGKcN/8A47pGLi/k58xHP/Tfw==",
+            "integrity": "sha512-gyyPk6rgonLFEDGoeRgQNaEUvdJ4ktTmmUh/h2t7s+M8oPpIPxgNACWa+6ESR57kXstwqPiCut0V8NRpcwgU7A==",
            "dev": true,
            "funding": [
                "https://github.com/fb55/htmlparser2?sponsor=1",
@@ -1737,7 +1757,7 @@
            "dependencies": {
                "domelementtype": "^2.0.1",
                "domhandler": "^4.0.0",
-                "domutils": "^2.4.4",
+                "domutils": "^2.5.2",
                "entities": "^2.0.0"
            }
        },
@@ -1830,9 +1850,9 @@
            }
        },
        "node_modules/is-core-module": {
-            "version": "2.2.0",
+            "version": "2.3.0",
-            "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.2.0.tgz",
+            "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.3.0.tgz",
-            "integrity": "sha512-XRAfAdyyY5F5cOXn7hYQDqh2Xmii+DEfIcQGxK/uNwMHhIkPWO0g8msXcbzLe+MpGoR951MlqM/2iIlU4vKDdQ==",
+            "integrity": "sha512-xSphU2KG9867tsYdLD4RWQ1VqdFl4HTO9Thf3I/3dLEfr0dbPTWKsuCKrgqMljg4nPE+Gq0VCnzT3gr0CyBmsw==",
            "dev": true,
            "dependencies": {
                "has": "^1.0.3"
@@ -2005,6 +2025,24 @@
            "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==",
            "dev": true
        },
+        "node_modules/lodash.clonedeep": {
+            "version": "4.5.0",
+            "resolved": "https://registry.npmjs.org/lodash.clonedeep/-/lodash.clonedeep-4.5.0.tgz",
+            "integrity": "sha1-4j8/nE+Pvd6HJSnBBxhXoIblzO8=",
+            "dev": true
+        },
+        "node_modules/lodash.flatten": {
+            "version": "4.4.0",
+            "resolved": "https://registry.npmjs.org/lodash.flatten/-/lodash.flatten-4.4.0.tgz",
+            "integrity": "sha1-8xwiIlqWMtK7+OSt2+8kCqdlph8=",
+            "dev": true
+        },
+        "node_modules/lodash.truncate": {
+            "version": "4.4.2",
+            "resolved": "https://registry.npmjs.org/lodash.truncate/-/lodash.truncate-4.4.2.tgz",
+            "integrity": "sha1-WjUNoLERO4N+z//VgSy+WNbq4ZM=",
+            "dev": true
+        },
        "node_modules/log-symbols": {
            "version": "4.0.0",
            "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-4.0.0.tgz",
@@ -2075,16 +2113,16 @@
            }
        },
        "node_modules/micromatch": {
-            "version": "4.0.2",
+            "version": "4.0.4",
-            "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.2.tgz",
+            "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.4.tgz",
-            "integrity": "sha512-y7FpHSbMUMoyPbYUSzO6PaZ6FyRnQOpHuKwbo1G+Knck95XVU4QAiKdGEnj5wwoS7PlOgthX/09u5iFJ+aYf5Q==",
+            "integrity": "sha512-pRmzw/XUcwXGpD9aI9q/0XOwLNygjETJ8y0ao0wdqprrzDa4YnxLcz7fQRZr8voh8V10kGhABbNcHVk5wHgWwg==",
            "dev": true,
            "dependencies": {
                "braces": "^3.0.1",
-                "picomatch": "^2.0.5"
+                "picomatch": "^2.2.3"
            },
            "engines": {
-                "node": ">=8"
+                "node": ">=8.6"
            }
        },
        "node_modules/mime": {
@@ -2100,21 +2138,21 @@
            }
        },
        "node_modules/mime-db": {
-            "version": "1.46.0",
+            "version": "1.47.0",
-            "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.46.0.tgz",
+            "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.47.0.tgz",
-            "integrity": "sha512-svXaP8UQRZ5K7or+ZmfNhg2xX3yKDMUzqadsSqi4NCH/KomcH75MAMYAGVlvXn4+b/xOPhS3I2uHKRUzvjY7BQ==",
+            "integrity": "sha512-QBmA/G2y+IfeS4oktet3qRZ+P5kPhCKRXxXnQEudYqUaEioAU1/Lq2us3D/t1Jfo4hE9REQPrbB7K5sOczJVIw==",
            "dev": true,
            "engines": {
                "node": ">= 0.6"
            }
        },
        "node_modules/mime-types": {
-            "version": "2.1.29",
+            "version": "2.1.30",
-            "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.29.tgz",
+            "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.30.tgz",
-            "integrity": "sha512-Y/jMt/S5sR9OaqteJtslsFZKWOIIqMACsJSiHghlCAyhf7jfVYjKBmLiX8OgpWeW+fjJ2b+Az69aPFPkUOY6xQ==",
+            "integrity": "sha512-crmjA4bLtR8m9qLpHvgxSChT+XoSlZi8J4n/aIdn3z92e/U47Z0V/yl+Wh9W046GgFVAmoNR/fmdbZYcSSIUeg==",
            "dev": true,
            "dependencies": {
-                "mime-db": "1.46.0"
+                "mime-db": "1.47.0"
            },
            "engines": {
                "node": ">= 0.6"
@@ -2150,9 +2188,9 @@
            }
        },
        "node_modules/mocha": {
-            "version": "8.3.0",
+            "version": "8.3.2",
-            "resolved": "https://registry.npmjs.org/mocha/-/mocha-8.3.0.tgz",
+            "resolved": "https://registry.npmjs.org/mocha/-/mocha-8.3.2.tgz",
-            "integrity": "sha512-TQqyC89V1J/Vxx0DhJIXlq9gbbL9XFNdeLQ1+JsnZsVaSOV1z3tWfw0qZmQJGQRIfkvZcs7snQnZnOCKoldq1Q==",
+            "integrity": "sha512-UdmISwr/5w+uXLPKspgoV7/RXZwKRTiTjJ2/AC5ZiEztIoOYdfKb19+9jNmEInzx5pBsCyJQzarAxqIGBNYJhg==",
            "dev": true,
            "dependencies": {
                "@ungap/promise-all-settled": "1.1.2",
@@ -2474,9 +2512,9 @@
            "dev": true
        },
        "node_modules/picomatch": {
-            "version": "2.2.2",
+            "version": "2.2.3",
-            "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.2.2.tgz",
+            "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.2.3.tgz",
-            "integrity": "sha512-q0M/9eZHzmr0AulXyPwNfZjtwZ/RBZlbN3K3CErVrk50T2ASYI7Bye0EvekFY3IP1Nt2DHu0re+V2ZHIpMkuWg==",
+            "integrity": "sha512-KpELjfwcCDUb9PeigTs2mBJzXUPzAuP2oPcA989He8Rte0+YUAjw1JVedDhuTKPkHjSYzMN3npC9luThGYEKdg==",
            "dev": true,
            "engines": {
                "node": ">=8.6"
@@ -2525,9 +2563,9 @@
            }
        },
        "node_modules/queue-microtask": {
-            "version": "1.2.2",
+            "version": "1.2.3",
-            "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.2.tgz",
+            "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
-            "integrity": "sha512-dB15eXv3p2jDlbOiNLyMabYg1/sXvppd8DP2J3EOCQ0AkuSXCW2tP7mnVouVLJKgUMY6yP0kcQDVpLCN13h4Xg==",
+            "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==",
            "dev": true,
            "funding": [
                {
@@ -2676,13 +2714,10 @@
            }
        },
        "node_modules/rollup": {
-            "version": "2.39.1",
+            "version": "2.45.2",
-            "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.39.1.tgz",
+            "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.45.2.tgz",
-            "integrity": "sha512-9rfr0Z6j+vE+eayfNVFr1KZ+k+jiUl2+0e4quZafy1x6SFCjzFspfRSO2ZZQeWeX9noeDTUDgg6eCENiEPFvQg==",
+            "integrity": "sha512-kRRU7wXzFHUzBIv0GfoFFIN3m9oteY4uAsKllIpQDId5cfnkWF2J130l+27dzDju0E6MScKiV0ZM5Bw8m4blYQ==",
            "dev": true,
-            "dependencies": {
-                "fsevents": "~2.3.1"
-            },
            "bin": {
                "rollup": "dist/bin/rollup"
            },
@@ -2737,9 +2772,9 @@
            ]
        },
        "node_modules/semver": {
-            "version": "7.3.4",
+            "version": "7.3.5",
-            "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.4.tgz",
+            "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.5.tgz",
-            "integrity": "sha512-tCfb2WLjqFAtXn4KEdxIhalnRtoKFN7nAwj0B3ZXCbQloV2tq5eDbcTmT68JJD3nRJq24/XgxtQKFIpQdtvmVw==",
+            "integrity": "sha512-PoeGJYh8HK4BTO/a9Tf6ZG3veo/A7ZVsYrSA6J8ny9nb3B1VrpkuN+z9OE5wfE5p6H4LchYZsegiQgbJD94ZFQ==",
            "dependencies": {
                "lru-cache": "^6.0.0"
            },
@@ -2846,9 +2881,9 @@
            "dev": true
        },
        "node_modules/string-width": {
-            "version": "4.2.0",
+            "version": "4.2.2",
-            "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.0.tgz",
+            "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.2.tgz",
-            "integrity": "sha512-zUz5JD+tgqtuDjMhwIg5uFVV3dtqZ9yQJlZVfq4I01/K5Paj5UHj7VyrQOJvzawSVlKpObApbfD0Ed6yJc+1eg==",
+            "integrity": "sha512-XBJbT3N4JhVumXE0eoLU9DCjcaF92KLNqTmFCnG1pf8duUxFGwtP6AD6nkjw9a3IdiRtL3E2w3JDiE/xi3vOeA==",
            "dev": true,
            "dependencies": {
                "emoji-regex": "^8.0.0",
@@ -2896,24 +2931,27 @@
            }
        },
        "node_modules/table": {
-            "version": "6.0.7",
+            "version": "6.5.1",
-            "resolved": "https://registry.npmjs.org/table/-/table-6.0.7.tgz",
+            "resolved": "https://registry.npmjs.org/table/-/table-6.5.1.tgz",
-            "integrity": "sha512-rxZevLGTUzWna/qBLObOe16kB2RTnnbhciwgPbMMlazz1yZGVEgnZK762xyVdVznhqxrfCeBMmMkgOOaPwjH7g==",
+            "integrity": "sha512-xGDXWTBJxahkzPQCsn1S9ESHEenU7TbMD5Iv4FeopXv/XwJyWatFjfbor+6ipI10/MNPXBYUamYukOrbPZ9L/w==",
            "dev": true,
            "dependencies": {
-                "ajv": "^7.0.2",
+                "ajv": "^8.0.1",
-                "lodash": "^4.17.20",
+                "lodash.clonedeep": "^4.5.0",
+                "lodash.flatten": "^4.4.0",
+                "lodash.truncate": "^4.4.2",
                "slice-ansi": "^4.0.0",
-                "string-width": "^4.2.0"
+                "string-width": "^4.2.0",
+                "strip-ansi": "^6.0.0"
            },
            "engines": {
                "node": ">=10.0.0"
            }
        },
        "node_modules/table/node_modules/ajv": {
-            "version": "7.1.1",
+            "version": "8.1.0",
-            "resolved": "https://registry.npmjs.org/ajv/-/ajv-7.1.1.tgz",
+            "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.1.0.tgz",
-            "integrity": "sha512-ga/aqDYnUy/o7vbsRTFhhTsNeXiYb5JWDIcRIeZfwRNCefwjNTVYCGdGSUrEmiu3yDK3vFvNbgJxvrQW4JXrYQ==",
+            "integrity": "sha512-B/Sk2Ix7A36fs/ZkuGLIR86EdjbgR6fsAcbx9lOP/QBSXujDNbVmIS/U4Itz5k8fPFDeVZl/zQ/gJW4Jrq6XjQ==",
            "dev": true,
            "dependencies": {
                "fast-deep-equal": "^3.1.1",
@@ -2969,15 +3007,15 @@
            "dev": true
        },
        "node_modules/tslib": {
-            "version": "2.1.0",
+            "version": "2.2.0",
-            "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.1.0.tgz",
+            "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.2.0.tgz",
-            "integrity": "sha512-hcVC3wYEziELGGmEEXue7D75zbwIIVUMWAVbHItGPx0ziyXxrOMQx4rQEVEV45Ut/1IotuEvwqPopzIOkDMf0A==",
+            "integrity": "sha512-gS9GVHRU+RGn5KQM2rllAlR3dU6m7AcpJKdtH8gFvQiC4Otgk98XnmMU+nZenHt/+VhnBPWwgrJsyrdcw6i23w==",
            "dev": true
        },
        "node_modules/tsutils": {
-            "version": "3.20.0",
+            "version": "3.21.0",
-            "resolved": "https://registry.npmjs.org/tsutils/-/tsutils-3.20.0.tgz",
+            "resolved": "https://registry.npmjs.org/tsutils/-/tsutils-3.21.0.tgz",
-            "integrity": "sha512-RYbuQuvkhuqVeXweWT3tJLKOEJ/UUw9GjNEZGWdrLLlM+611o1gwLHBpxoFJKKl25fLprp2eVthtKs5JOrNeXg==",
+            "integrity": "sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==",
            "dev": true,
            "dependencies": {
                "tslib": "^1.8.1"
@@ -3017,12 +3055,15 @@
            }
        },
        "node_modules/type-fest": {
-            "version": "0.8.1",
+            "version": "0.20.2",
-            "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.8.1.tgz",
+            "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz",
-            "integrity": "sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==",
+            "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==",
            "dev": true,
            "engines": {
-                "node": ">=8"
+                "node": ">=10"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
            }
        },
        "node_modules/typed-rest-client": {
@@ -3036,9 +3077,9 @@
            }
        },
        "node_modules/typescript": {
-            "version": "4.1.5",
+            "version": "4.2.4",
-            "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.1.5.tgz",
+            "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.2.4.tgz",
-            "integrity": "sha512-6OSu9PTIzmn9TCDiovULTnET6BgXtDYL4Gg4szY+cGsc3JP1dQL8qvE8kShTRx1NIw4Q9IBHlwODjkjWEtMUyA==",
+            "integrity": "sha512-V+evlYHZnQkaz8TRBuxTA92yZBPotr5H+WhQ7bD3hZUndx5tGOa1fuCgeSjxAzM1RiN5IzvadIXTVefuuwZCRg==",
            "dev": true,
            "bin": {
                "tsc": "bin/tsc",
@@ -3119,15 +3160,15 @@
            "dev": true
        },
        "node_modules/v8-compile-cache": {
-            "version": "2.2.0",
+            "version": "2.3.0",
-            "resolved": "https://registry.npmjs.org/v8-compile-cache/-/v8-compile-cache-2.2.0.tgz",
+            "resolved": "https://registry.npmjs.org/v8-compile-cache/-/v8-compile-cache-2.3.0.tgz",
-            "integrity": "sha512-gTpR5XQNKFwOd4clxfnhaqvfqMpqEwr4tOtCyz4MtYZX2JYhfr1JvBFKdS+7K/9rfpZR3VLX+YWBbKoxCgS43Q==",
+            "integrity": "sha512-l8lCEmLcLYZh4nbunNZvQCJc5pv7+RCwa8q/LdUx8u7lsWvPDKmpodJAJNwkAhJC//dFY48KuIEmjtd4RViDrA==",
            "dev": true
        },
        "node_modules/vsce": {
-            "version": "1.85.0",
+            "version": "1.87.1",
-            "resolved": "https://registry.npmjs.org/vsce/-/vsce-1.85.0.tgz",
+            "resolved": "https://registry.npmjs.org/vsce/-/vsce-1.87.1.tgz",
-            "integrity": "sha512-YVFwjXWvHRwk75mm3iL4Wr3auCdbBPTv2amtLf97ccqH0hkt0ZVBddu7iOs4HSEbSr9xiiaZwQHUsqMm6Ks0ag==",
+            "integrity": "sha512-3tSUWZl9AmhZrqy/UVUpdPODSzBiCGjIr/AMSSgF2PuFLSdrh+6kiOr2Ath7bpQEXOxf55hNgz3qdO5MuEJmww==",
            "dev": true,
            "dependencies": {
                "azure-devops-node-api": "^7.2.0",
@@ -3283,9 +3324,9 @@
            "integrity": "sha512-VGzh06oynbYa6JbTKUbxOEZN7CYEtWhN7DK5wfzUpeCJl8X8xZX39g2PVfpqXrIEduu7dcJgK007KgnX9tHNKA=="
        },
        "node_modules/vscode-test": {
-            "version": "1.5.1",
+            "version": "1.5.2",
-            "resolved": "https://registry.npmjs.org/vscode-test/-/vscode-test-1.5.1.tgz",
+            "resolved": "https://registry.npmjs.org/vscode-test/-/vscode-test-1.5.2.tgz",
-            "integrity": "sha512-tDloz6euDne+GeUSglhufL0c2xhuYAPAT74hjsuGxfflALfXF9bYnJ7ehZEeVkr/ZnQEh/T8EBrfPL+m0h5qEQ==",
+            "integrity": "sha512-x9PVfKxF6EInH9iSFGQi0V8H5zIW1fC7RAer6yNQR6sy3WyOwlWkuT3I+wf75xW/cO53hxMi1aj/EvqQfDFOAg==",
            "dev": true,
            "dependencies": {
                "http-proxy-agent": "^4.0.1",
@@ -3403,9 +3444,9 @@
            "dev": true
        },
        "node_modules/y18n": {
-            "version": "5.0.5",
+            "version": "5.0.8",
-            "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.5.tgz",
+            "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
-            "integrity": "sha512-hsRUr4FFrvhhRH12wOdfs38Gy7k2FFzB9qgN9v3aLykRq0dRcdcpz5C9FxdS2NuhOrI/628b/KSTJ3rwHysYSg==",
+            "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
            "dev": true,
            "engines": {
                "node": ">=10"
@@ -3507,9 +3548,9 @@
            "dev": true
        },
        "@babel/highlight": {
-            "version": "7.12.13",
+            "version": "7.13.10",
-            "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.12.13.tgz",
+            "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.13.10.tgz",
-            "integrity": "sha512-kocDQvIbgMKlWxXe9fof3TQ+gkIPOUSEYhJjqUjvKMez3krV7vbzYCDq39Oj11UAVK7JqPVGQPlgE85dPNlQww==",
+            "integrity": "sha512-5aPpe5XQPzflQrFwL1/QoeHkP2MsA4JCntcXHRhEsdsfPVkvPi2w7Qix4iV7t5S/oC9OodGrggd8aco1g3SZFg==",
            "dev": true,
            "requires": {
                "@babel/helper-validator-identifier": "^7.12.11",
@@ -3576,9 +3617,9 @@
            }
        },
        "@eslint/eslintrc": {
-            "version": "0.3.0",
+            "version": "0.4.0",
-            "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-0.3.0.tgz",
+            "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-0.4.0.tgz",
-            "integrity": "sha512-1JTKgrOKAHVivSvOYw+sJOunkBjUOvjqWk1DPja7ZFhIS2mX/4EgTT8M7eTK9jrKhL/FvXXEbQwIs3pg1xp3dg==",
+            "integrity": "sha512-2ZPCc+uNbjV5ERJr+aKSPRwZgKd2z11x0EgLvb1PURmUrn9QNRXFqje0Ldq454PfAVyaJYyrDvvIKSFP4NnBog==",
            "dev": true,
            "requires": {
                "ajv": "^6.12.4",
@@ -3588,9 +3629,25 @@
                "ignore": "^4.0.6",
                "import-fresh": "^3.2.1",
                "js-yaml": "^3.13.1",
-                "lodash": "^4.17.20",
                "minimatch": "^3.0.4",
                "strip-json-comments": "^3.1.1"
+            },
+            "dependencies": {
+                "globals": {
+                    "version": "12.4.0",
+                    "resolved": "https://registry.npmjs.org/globals/-/globals-12.4.0.tgz",
+                    "integrity": "sha512-BWICuzzDvDoH54NHKCseDanAhE3CeDorgDL5MT6LMXXj2WCnd9UC2szdk4AWLfjdgNBCXLUanXYcpBBKOSWGwg==",
+                    "dev": true,
+                    "requires": {
+                        "type-fest": "^0.8.1"
+                    }
+                },
+                "type-fest": {
+                    "version": "0.8.1",
+                    "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.8.1.tgz",
+                    "integrity": "sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==",
+                    "dev": true
+                }
            }
        },
        "@nodelib/fs.scandir": {
@@ -3635,9 +3692,9 @@
            }
        },
        "@rollup/plugin-node-resolve": {
-            "version": "11.2.0",
+            "version": "11.2.1",
-            "resolved": "https://registry.npmjs.org/@rollup/plugin-node-resolve/-/plugin-node-resolve-11.2.0.tgz",
+            "resolved": "https://registry.npmjs.org/@rollup/plugin-node-resolve/-/plugin-node-resolve-11.2.1.tgz",
-            "integrity": "sha512-qHjNIKYt5pCcn+5RUBQxK8krhRvf1HnyVgUCcFFcweDS7fhkOLZeYh0mhHK6Ery8/bb9tvN/ubPzmfF0qjDCTA==",
+            "integrity": "sha512-yc2n43jcqVyGE2sqV5/YCmocy9ArjVAP/BeXyTtADTBBX6V0e5UMqwO8CdQ0kzjb6zu5P1qMzsScCMRvE9OlVg==",
            "dev": true,
            "requires": {
                "@rollup/pluginutils": "^3.1.0",
@@ -3696,15 +3753,15 @@
            "dev": true
        },
        "@types/minimatch": {
-            "version": "3.0.3",
+            "version": "3.0.4",
-            "resolved": "https://registry.npmjs.org/@types/minimatch/-/minimatch-3.0.3.tgz",
+            "resolved": "https://registry.npmjs.org/@types/minimatch/-/minimatch-3.0.4.tgz",
-            "integrity": "sha512-tHq6qdbT9U1IRSGf14CL0pUlULksvY9OZ+5eEgl1N7t+OA3tGvNpxJCzuKQlsNgCVwbAs670L1vcVQi8j9HjnA==",
+            "integrity": "sha512-1z8k4wzFnNjVK/tlxvrWuK5WMt6mydWWP7+zvH5eFep4oj+UkrfiJTRtjCeBXNpwaA/FYqqtb4/QS4ianFpIRA==",
            "dev": true
        },
        "@types/mocha": {
-            "version": "8.2.1",
+            "version": "8.2.2",
-            "resolved": "https://registry.npmjs.org/@types/mocha/-/mocha-8.2.1.tgz",
+            "resolved": "https://registry.npmjs.org/@types/mocha/-/mocha-8.2.2.tgz",
-            "integrity": "sha512-NysN+bNqj6E0Hv4CTGWSlPzMW6vTKjDpOteycDkV4IWBsO+PU48JonrPzV9ODjiI2XrjmA05KInLgF5ivZ/YGQ==",
+            "integrity": "sha512-Lwh0lzzqT5Pqh6z61P3c3P5nm6fzQK/MMHl9UKeneAeInVflBSz1O2EkX6gM6xfJd7FBXBY5purtLx7fUiZ7Hw==",
            "dev": true
        },
        "@types/node": {
@@ -3714,9 +3771,9 @@
            "dev": true
        },
        "@types/node-fetch": {
-            "version": "2.5.8",
+            "version": "2.5.10",
-            "resolved": "https://registry.npmjs.org/@types/node-fetch/-/node-fetch-2.5.8.tgz",
+            "resolved": "https://registry.npmjs.org/@types/node-fetch/-/node-fetch-2.5.10.tgz",
-            "integrity": "sha512-fbjI6ja0N5ZA8TV53RUqzsKNkl9fv8Oj3T7zxW7FGv1GSH7gwJaNF8dzCjrqKaxKeUpTz4yT1DaJFq/omNpGfw==",
+            "integrity": "sha512-IpkX0AasN44hgEad0gEF/V6EgR5n69VEqPEgnmoM8GsIGro3PowbWs4tR6IhxUTyPLpOn+fiGG6nrQhcmoCuIQ==",
            "dev": true,
            "requires": {
                "@types/node": "*",
@@ -3733,19 +3790,19 @@
            }
        },
        "@types/vscode": {
-            "version": "1.53.0",
+            "version": "1.55.0",
-            "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.53.0.tgz",
+            "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.55.0.tgz",
-            "integrity": "sha512-XjFWbSPOM0EKIT2XhhYm3D3cx3nn3lshMUcWNy1eqefk+oqRuBq8unVb6BYIZqXy9lQZyeUl7eaBCOZWv+LcXQ==",
+            "integrity": "sha512-49hysH7jneTQoSC8TWbAi7nKK9Lc5osQNjmDHVosrcU8o3jecD9GrK0Qyul8q4aGPSXRfNGqIp9CBdb13akETg==",
            "dev": true
        },
        "@typescript-eslint/eslint-plugin": {
-            "version": "4.15.2",
+            "version": "4.22.0",
-            "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-4.15.2.tgz",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-4.22.0.tgz",
-            "integrity": "sha512-uiQQeu9tWl3f1+oK0yoAv9lt/KXO24iafxgQTkIYO/kitruILGx3uH+QtIAHqxFV+yIsdnJH+alel9KuE3J15Q==",
+            "integrity": "sha512-U8SP9VOs275iDXaL08Ln1Fa/wLXfj5aTr/1c0t0j6CdbOnxh+TruXu1p4I0NAvdPBQgoPjHsgKn28mOi0FzfoA==",
            "dev": true,
            "requires": {
-                "@typescript-eslint/experimental-utils": "4.15.2",
+                "@typescript-eslint/experimental-utils": "4.22.0",
-                "@typescript-eslint/scope-manager": "4.15.2",
+                "@typescript-eslint/scope-manager": "4.22.0",
                "debug": "^4.1.1",
                "functional-red-black-tree": "^1.0.1",
                "lodash": "^4.17.15",
@@ -3755,55 +3812,55 @@
            }
        },
        "@typescript-eslint/experimental-utils": {
-            "version": "4.15.2",
+            "version": "4.22.0",
-            "resolved": "https://registry.npmjs.org/@typescript-eslint/experimental-utils/-/experimental-utils-4.15.2.tgz",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/experimental-utils/-/experimental-utils-4.22.0.tgz",
-            "integrity": "sha512-Fxoshw8+R5X3/Vmqwsjc8nRO/7iTysRtDqx6rlfLZ7HbT8TZhPeQqbPjTyk2RheH3L8afumecTQnUc9EeXxohQ==",
+            "integrity": "sha512-xJXHHl6TuAxB5AWiVrGhvbGL8/hbiCQ8FiWwObO3r0fnvBdrbWEDy1hlvGQOAWc6qsCWuWMKdVWlLAEMpxnddg==",
            "dev": true,
            "requires": {
                "@types/json-schema": "^7.0.3",
-                "@typescript-eslint/scope-manager": "4.15.2",
+                "@typescript-eslint/scope-manager": "4.22.0",
-                "@typescript-eslint/types": "4.15.2",
+                "@typescript-eslint/types": "4.22.0",
-                "@typescript-eslint/typescript-estree": "4.15.2",
+                "@typescript-eslint/typescript-estree": "4.22.0",
                "eslint-scope": "^5.0.0",
                "eslint-utils": "^2.0.0"
            }
        },
        "@typescript-eslint/parser": {
-            "version": "4.15.2",
+            "version": "4.22.0",
-            "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-4.15.2.tgz",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-4.22.0.tgz",
-            "integrity": "sha512-SHeF8xbsC6z2FKXsaTb1tBCf0QZsjJ94H6Bo51Y1aVEZ4XAefaw5ZAilMoDPlGghe+qtq7XdTiDlGfVTOmvA+Q==",
+            "integrity": "sha512-z/bGdBJJZJN76nvAY9DkJANYgK3nlRstRRi74WHm3jjgf2I8AglrSY+6l7ogxOmn55YJ6oKZCLLy+6PW70z15Q==",
            "dev": true,
            "requires": {
-                "@typescript-eslint/scope-manager": "4.15.2",
+                "@typescript-eslint/scope-manager": "4.22.0",
-                "@typescript-eslint/types": "4.15.2",
+                "@typescript-eslint/types": "4.22.0",
-                "@typescript-eslint/typescript-estree": "4.15.2",
+                "@typescript-eslint/typescript-estree": "4.22.0",
                "debug": "^4.1.1"
            }
        },
        "@typescript-eslint/scope-manager": {
-            "version": "4.15.2",
+            "version": "4.22.0",
-            "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-4.15.2.tgz",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-4.22.0.tgz",
-            "integrity": "sha512-Zm0tf/MSKuX6aeJmuXexgdVyxT9/oJJhaCkijv0DvJVT3ui4zY6XYd6iwIo/8GEZGy43cd7w1rFMiCLHbRzAPQ==",
+            "integrity": "sha512-OcCO7LTdk6ukawUM40wo61WdeoA7NM/zaoq1/2cs13M7GyiF+T4rxuA4xM+6LeHWjWbss7hkGXjFDRcKD4O04Q==",
            "dev": true,
            "requires": {
-                "@typescript-eslint/types": "4.15.2",
+                "@typescript-eslint/types": "4.22.0",
-                "@typescript-eslint/visitor-keys": "4.15.2"
+                "@typescript-eslint/visitor-keys": "4.22.0"
            }
        },
        "@typescript-eslint/types": {
-            "version": "4.15.2",
+            "version": "4.22.0",
-            "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-4.15.2.tgz",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-4.22.0.tgz",
-            "integrity": "sha512-r7lW7HFkAarfUylJ2tKndyO9njwSyoy6cpfDKWPX6/ctZA+QyaYscAHXVAfJqtnY6aaTwDYrOhp+ginlbc7HfQ==",
+            "integrity": "sha512-sW/BiXmmyMqDPO2kpOhSy2Py5w6KvRRsKZnV0c4+0nr4GIcedJwXAq+RHNK4lLVEZAJYFltnnk1tJSlbeS9lYA==",
            "dev": true
        },
        "@typescript-eslint/typescript-estree": {
-            "version": "4.15.2",
+            "version": "4.22.0",
-            "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-4.15.2.tgz",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-4.22.0.tgz",
-            "integrity": "sha512-cGR8C2g5SPtHTQvAymEODeqx90pJHadWsgTtx6GbnTWKqsg7yp6Eaya9nFzUd4KrKhxdYTTFBiYeTPQaz/l8bw==",
+            "integrity": "sha512-TkIFeu5JEeSs5ze/4NID+PIcVjgoU3cUQUIZnH3Sb1cEn1lBo7StSV5bwPuJQuoxKXlzAObjYTilOEKRuhR5yg==",
            "dev": true,
            "requires": {
-                "@typescript-eslint/types": "4.15.2",
+                "@typescript-eslint/types": "4.22.0",
-                "@typescript-eslint/visitor-keys": "4.15.2",
+                "@typescript-eslint/visitor-keys": "4.22.0",
                "debug": "^4.1.1",
                "globby": "^11.0.1",
                "is-glob": "^4.0.1",
@@ -3812,12 +3869,12 @@
            }
        },
        "@typescript-eslint/visitor-keys": {
-            "version": "4.15.2",
+            "version": "4.22.0",
-            "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-4.15.2.tgz",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-4.22.0.tgz",
-            "integrity": "sha512-TME1VgSb7wTwgENN5KVj4Nqg25hP8DisXxNBojM4Nn31rYaNDIocNm5cmjOFfh42n7NVERxWrDFoETO/76ePyg==",
+            "integrity": "sha512-nnMu4F+s4o0sll6cBSsTeVsT4cwxB7zECK3dFxzEjPBii9xLpq4yqqsy/FU5zMfan6G60DKZSCXAa3sHJZrcYw==",
            "dev": true,
            "requires": {
-                "@typescript-eslint/types": "4.15.2",
+                "@typescript-eslint/types": "4.22.0",
                "eslint-visitor-keys": "^2.0.0"
            }
        },
@@ -3882,9 +3939,9 @@
            }
        },
        "anymatch": {
-            "version": "3.1.1",
+            "version": "3.1.2",
-            "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.1.tgz",
+            "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.2.tgz",
-            "integrity": "sha512-mM8522psRCqzV+6LhomX5wgp25YVibjh8Wj23I5RPkPppSVSjyKD2A2mBJmWGa+KN7f2D6LNh9jkBCeyLktzjg==",
+            "integrity": "sha512-P43ePfOAIupkguHUycrc4qJ9kz8ZiuOUijaETwX7THt0Y/GNK7v0aa8rY816xWjZ7rJdA5XdMcpVFTKMq+RvWg==",
            "dev": true,
            "requires": {
                "normalize-path": "^3.0.0",
@@ -3931,9 +3988,9 @@
            }
        },
        "balanced-match": {
-            "version": "1.0.0",
+            "version": "1.0.2",
-            "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz",
+            "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
-            "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c="
+            "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="
        },
        "big-integer": {
            "version": "1.6.48",
@@ -4039,9 +4096,9 @@
            }
        },
        "chalk": {
-            "version": "4.1.0",
+            "version": "4.1.1",
-            "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.0.tgz",
+            "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.1.tgz",
-            "integrity": "sha512-qwx12AxXe2Q5xQ43Ac//I6v5aXTipYrSESdOgzrN+9XjgEpyjpKuvSGaN4qE93f7TQTlerQQ8S+EQ0EyDoVL1A==",
+            "integrity": "sha512-diHzdDKxcU+bAsUboHLPEDQiw0qEe0qd7SYUn3HgcFlWgbDcfLGswOHYeGrHKzG9z6UYf01d9VFMfZxPM1xZSg==",
            "dev": true,
            "requires": {
                "ansi-styles": "^4.1.0",
@@ -4049,31 +4106,30 @@
            }
        },
        "cheerio": {
-            "version": "1.0.0-rc.5",
+            "version": "1.0.0-rc.6",
-            "resolved": "https://registry.npmjs.org/cheerio/-/cheerio-1.0.0-rc.5.tgz",
+            "resolved": "https://registry.npmjs.org/cheerio/-/cheerio-1.0.0-rc.6.tgz",
-            "integrity": "sha512-yoqps/VCaZgN4pfXtenwHROTp8NG6/Hlt4Jpz2FEP0ZJQ+ZUkVDd0hAPDNKhj3nakpfPt/CNs57yEtxD1bXQiw==",
+            "integrity": "sha512-hjx1XE1M/D5pAtMgvWwE21QClmAEeGHOIDfycgmndisdNgI6PE1cGRQkMGBcsbUbmEQyWu5PJLUcAOjtQS8DWw==",
            "dev": true,
            "requires": {
-                "cheerio-select-tmp": "^0.1.0",
+                "cheerio-select": "^1.3.0",
-                "dom-serializer": "~1.2.0",
+                "dom-serializer": "^1.3.1",
-                "domhandler": "^4.0.0",
+                "domhandler": "^4.1.0",
-                "entities": "~2.1.0",
+                "htmlparser2": "^6.1.0",
-                "htmlparser2": "^6.0.0",
+                "parse5": "^6.0.1",
-                "parse5": "^6.0.0",
+                "parse5-htmlparser2-tree-adapter": "^6.0.1"
-                "parse5-htmlparser2-tree-adapter": "^6.0.0"
            }
        },
-        "cheerio-select-tmp": {
+        "cheerio-select": {
-            "version": "0.1.1",
+            "version": "1.4.0",
-            "resolved": "https://registry.npmjs.org/cheerio-select-tmp/-/cheerio-select-tmp-0.1.1.tgz",
+            "resolved": "https://registry.npmjs.org/cheerio-select/-/cheerio-select-1.4.0.tgz",
-            "integrity": "sha512-YYs5JvbpU19VYJyj+F7oYrIE2BOll1/hRU7rEy/5+v9BzkSo3bK81iAeeQEMI92vRIxz677m72UmJUiVwwgjfQ==",
+            "integrity": "sha512-sobR3Yqz27L553Qa7cK6rtJlMDbiKPdNywtR95Sj/YgfpLfy0u6CGJuaBKe5YE/vTc23SCRKxWSdlon/w6I/Ew==",
            "dev": true,
            "requires": {
-                "css-select": "^3.1.2",
+                "css-select": "^4.1.2",
-                "css-what": "^4.0.0",
+                "css-what": "^5.0.0",
-                "domelementtype": "^2.1.0",
+                "domelementtype": "^2.2.0",
-                "domhandler": "^4.0.0",
+                "domhandler": "^4.2.0",
-                "domutils": "^2.4.4"
+                "domutils": "^2.6.0"
            }
        },
        "chokidar": {
@@ -4168,22 +4224,22 @@
            }
        },
        "css-select": {
-            "version": "3.1.2",
+            "version": "4.1.2",
-            "resolved": "https://registry.npmjs.org/css-select/-/css-select-3.1.2.tgz",
+            "resolved": "https://registry.npmjs.org/css-select/-/css-select-4.1.2.tgz",
-            "integrity": "sha512-qmss1EihSuBNWNNhHjxzxSfJoFBM/lERB/Q4EnsJQQC62R2evJDW481091oAdOr9uh46/0n4nrg0It5cAnj1RA==",
+            "integrity": "sha512-nu5ye2Hg/4ISq4XqdLY2bEatAcLIdt3OYGFc9Tm9n7VSlFBcfRv0gBNksHRgSdUDQGtN3XrZ94ztW+NfzkFSUw==",
            "dev": true,
            "requires": {
                "boolbase": "^1.0.0",
-                "css-what": "^4.0.0",
+                "css-what": "^5.0.0",
-                "domhandler": "^4.0.0",
+                "domhandler": "^4.2.0",
-                "domutils": "^2.4.3",
+                "domutils": "^2.6.0",
                "nth-check": "^2.0.0"
            }
        },
        "css-what": {
-            "version": "4.0.0",
+            "version": "5.0.0",
-            "resolved": "https://registry.npmjs.org/css-what/-/css-what-4.0.0.tgz",
+            "resolved": "https://registry.npmjs.org/css-what/-/css-what-5.0.0.tgz",
-            "integrity": "sha512-teijzG7kwYfNVsUh2H/YN62xW3KK9YhXEgSlbxMlcyjPNvdKJqFx5lrwlJgoFP1ZHlB89iGDlo/JyshKeRhv5A==",
+            "integrity": "sha512-qxyKHQvgKwzwDWC/rGbT821eJalfupxYW2qbSJSAtdSTimsr/MlaGONoNLllaUPZWf8QnbcKM/kPVYUQuEKAFA==",
            "dev": true
        },
        "debug": {
@@ -4249,9 +4305,9 @@
            }
        },
        "dom-serializer": {
-            "version": "1.2.0",
+            "version": "1.3.1",
-            "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-1.2.0.tgz",
+            "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-1.3.1.tgz",
-            "integrity": "sha512-n6kZFH/KlCrqs/1GHMOd5i2fd/beQHuehKdWvNNffbGHTr/almdhuVvTVFb3V7fglz+nC50fFusu3lY33h12pA==",
+            "integrity": "sha512-Pv2ZluG5ife96udGgEDovOOOA5UELkltfJpnIExPrAk1LTvecolUGn6lIaoLh86d83GiB86CjzciMd9BuRB71Q==",
            "dev": true,
            "requires": {
                "domelementtype": "^2.0.1",
@@ -4260,29 +4316,29 @@
            }
        },
        "domelementtype": {
-            "version": "2.1.0",
+            "version": "2.2.0",
-            "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-2.1.0.tgz",
+            "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-2.2.0.tgz",
-            "integrity": "sha512-LsTgx/L5VpD+Q8lmsXSHW2WpA+eBlZ9HPf3erD1IoPF00/3JKHZ3BknUVA2QGDNu69ZNmyFmCWBSO45XjYKC5w==",
+            "integrity": "sha512-DtBMo82pv1dFtUmHyr48beiuq792Sxohr+8Hm9zoxklYPfa6n0Z3Byjj2IV7bmr2IyqClnqEQhfgHJJ5QF0R5A==",
            "dev": true
        },
        "domhandler": {
-            "version": "4.0.0",
+            "version": "4.2.0",
-            "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-4.0.0.tgz",
+            "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-4.2.0.tgz",
-            "integrity": "sha512-KPTbnGQ1JeEMQyO1iYXoagsI6so/C96HZiFyByU3T6iAzpXn8EGEvct6unm1ZGoed8ByO2oirxgwxBmqKF9haA==",
+            "integrity": "sha512-zk7sgt970kzPks2Bf+dwT/PLzghLnsivb9CcxkvR8Mzr66Olr0Ofd8neSbglHJHaHa2MadfoSdNlKYAaafmWfA==",
            "dev": true,
            "requires": {
-                "domelementtype": "^2.1.0"
+                "domelementtype": "^2.2.0"
            }
        },
        "domutils": {
-            "version": "2.4.4",
+            "version": "2.6.0",
-            "resolved": "https://registry.npmjs.org/domutils/-/domutils-2.4.4.tgz",
+            "resolved": "https://registry.npmjs.org/domutils/-/domutils-2.6.0.tgz",
-            "integrity": "sha512-jBC0vOsECI4OMdD0GC9mGn7NXPLb+Qt6KW1YDQzeQYRUFKmNG8lh7mO5HiELfr+lLQE7loDVI4QcAxV80HS+RA==",
+            "integrity": "sha512-y0BezHuy4MDYxh6OvolXYsH+1EMGmFbwv5FKW7ovwMG6zTPWqNPq3WF9ayZssFq+UlKdffGLbOEaghNdaOm1WA==",
            "dev": true,
            "requires": {
                "dom-serializer": "^1.0.1",
-                "domelementtype": "^2.0.1",
+                "domelementtype": "^2.2.0",
-                "domhandler": "^4.0.0"
+                "domhandler": "^4.2.0"
            }
        },
        "duplexer2": {
@@ -4346,9 +4402,9 @@
            }
        },
        "entities": {
-            "version": "2.1.0",
+            "version": "2.2.0",
-            "resolved": "https://registry.npmjs.org/entities/-/entities-2.1.0.tgz",
+            "resolved": "https://registry.npmjs.org/entities/-/entities-2.2.0.tgz",
-            "integrity": "sha512-hCx1oky9PFrJ611mf0ifBLBRW8lUUVRlFolb5gWRfIELabBlbp9xZvrqZLZAs+NxFnbfQoeGd8wDkygjg7U85w==",
+            "integrity": "sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A==",
            "dev": true
        },
        "escalade": {
@@ -4364,13 +4420,13 @@
            "dev": true
        },
        "eslint": {
-            "version": "7.20.0",
+            "version": "7.25.0",
-            "resolved": "https://registry.npmjs.org/eslint/-/eslint-7.20.0.tgz",
+            "resolved": "https://registry.npmjs.org/eslint/-/eslint-7.25.0.tgz",
-            "integrity": "sha512-qGi0CTcOGP2OtCQBgWZlQjcTuP0XkIpYFj25XtRTQSHC+umNnp7UMshr2G8SLsRFYDdAPFeHOsiteadmMH02Yw==",
+            "integrity": "sha512-TVpSovpvCNpLURIScDRB6g5CYu/ZFq9GfX2hLNIV4dSBKxIWojeDODvYl3t0k0VtMxYeR8OXPCFE5+oHMlGfhw==",
            "dev": true,
            "requires": {
                "@babel/code-frame": "7.12.11",
-                "@eslint/eslintrc": "^0.3.0",
+                "@eslint/eslintrc": "^0.4.0",
                "ajv": "^6.10.0",
                "chalk": "^4.0.0",
                "cross-spawn": "^7.0.2",
@@ -4383,10 +4439,10 @@
                "espree": "^7.3.1",
                "esquery": "^1.4.0",
                "esutils": "^2.0.2",
-                "file-entry-cache": "^6.0.0",
+                "file-entry-cache": "^6.0.1",
                "functional-red-black-tree": "^1.0.1",
                "glob-parent": "^5.0.0",
-                "globals": "^12.1.0",
+                "globals": "^13.6.0",
                "ignore": "^4.0.6",
                "import-fresh": "^3.0.0",
                "imurmurhash": "^0.1.4",
@@ -4394,7 +4450,7 @@
                "js-yaml": "^3.13.1",
                "json-stable-stringify-without-jsonify": "^1.0.1",
                "levn": "^0.4.1",
-                "lodash": "^4.17.20",
+                "lodash": "^4.17.21",
                "minimatch": "^3.0.4",
                "natural-compare": "^1.4.0",
                "optionator": "^0.9.1",
@@ -4551,9 +4607,9 @@
            "dev": true
        },
        "fastq": {
-            "version": "1.10.1",
+            "version": "1.11.0",
-            "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.10.1.tgz",
+            "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.11.0.tgz",
-            "integrity": "sha512-AWuv6Ery3pM+dY7LYS8YIaCiQvUaos9OB1RyNgaOWnaX+Tik7Onvcsf8x8c+YtDeT0maYLniBip2hox5KtEXXA==",
+            "integrity": "sha512-7Eczs8gIPDrVzT+EksYBcupqMyxSHXXrHOLRRxU2/DicV8789MRBRR8+Hc2uWzUupOs4YS4JzBmBxjjCVBxD/g==",
            "dev": true,
            "requires": {
                "reusify": "^1.0.4"
@@ -4698,27 +4754,27 @@
            }
        },
        "glob-parent": {
-            "version": "5.1.1",
+            "version": "5.1.2",
-            "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.1.tgz",
+            "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
-            "integrity": "sha512-FnI+VGOpnlGHWZxthPGR+QhR78fuiK0sNLkHQv+bL9fQi57lNNdquIbna/WrfROrolq8GK5Ek6BiMwqL/voRYQ==",
+            "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
            "dev": true,
            "requires": {
                "is-glob": "^4.0.1"
            }
        },
        "globals": {
-            "version": "12.4.0",
+            "version": "13.8.0",
-            "resolved": "https://registry.npmjs.org/globals/-/globals-12.4.0.tgz",
+            "resolved": "https://registry.npmjs.org/globals/-/globals-13.8.0.tgz",
-            "integrity": "sha512-BWICuzzDvDoH54NHKCseDanAhE3CeDorgDL5MT6LMXXj2WCnd9UC2szdk4AWLfjdgNBCXLUanXYcpBBKOSWGwg==",
+            "integrity": "sha512-rHtdA6+PDBIjeEvA91rpqzEvk/k3/i7EeNQiryiWuJH0Hw9cpyJMAt2jtbAwUaRdhD+573X4vWw6IcjKPasi9Q==",
            "dev": true,
            "requires": {
-                "type-fest": "^0.8.1"
+                "type-fest": "^0.20.2"
            }
        },
        "globby": {
-            "version": "11.0.2",
+            "version": "11.0.3",
-            "resolved": "https://registry.npmjs.org/globby/-/globby-11.0.2.tgz",
+            "resolved": "https://registry.npmjs.org/globby/-/globby-11.0.3.tgz",
-            "integrity": "sha512-2ZThXDvvV8fYFRVIxnrMQBipZQDr7MxKAmQK1vujaj9/7eF0efG7BPUKJ7jP7G5SLF37xKDXvO4S/KKLj/Z0og==",
+            "integrity": "sha512-ffdmosjA807y7+lA1NM0jELARVmYul/715xiILEjo3hBLPTcirgQNnXECn5g3mtR8TOLCVbkfua1Hpen25/Xcg==",
            "dev": true,
            "requires": {
                "array-union": "^2.1.0",
@@ -4771,14 +4827,14 @@
            "dev": true
        },
        "htmlparser2": {
-            "version": "6.0.0",
+            "version": "6.1.0",
-            "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-6.0.0.tgz",
+            "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-6.1.0.tgz",
-            "integrity": "sha512-numTQtDZMoh78zJpaNdJ9MXb2cv5G3jwUoe3dMQODubZvLoGvTE/Ofp6sHvH8OGKcN/8A47pGLi/k58xHP/Tfw==",
+            "integrity": "sha512-gyyPk6rgonLFEDGoeRgQNaEUvdJ4ktTmmUh/h2t7s+M8oPpIPxgNACWa+6ESR57kXstwqPiCut0V8NRpcwgU7A==",
            "dev": true,
            "requires": {
                "domelementtype": "^2.0.1",
                "domhandler": "^4.0.0",
-                "domutils": "^2.4.4",
+                "domutils": "^2.5.2",
                "entities": "^2.0.0"
            }
        },
@@ -4850,9 +4906,9 @@
            }
        },
        "is-core-module": {
-            "version": "2.2.0",
+            "version": "2.3.0",
-            "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.2.0.tgz",
+            "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.3.0.tgz",
-            "integrity": "sha512-XRAfAdyyY5F5cOXn7hYQDqh2Xmii+DEfIcQGxK/uNwMHhIkPWO0g8msXcbzLe+MpGoR951MlqM/2iIlU4vKDdQ==",
+            "integrity": "sha512-xSphU2KG9867tsYdLD4RWQ1VqdFl4HTO9Thf3I/3dLEfr0dbPTWKsuCKrgqMljg4nPE+Gq0VCnzT3gr0CyBmsw==",
            "dev": true,
            "requires": {
                "has": "^1.0.3"
@@ -4992,6 +5048,24 @@
            "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==",
            "dev": true
        },
+        "lodash.clonedeep": {
+            "version": "4.5.0",
+            "resolved": "https://registry.npmjs.org/lodash.clonedeep/-/lodash.clonedeep-4.5.0.tgz",
+            "integrity": "sha1-4j8/nE+Pvd6HJSnBBxhXoIblzO8=",
+            "dev": true
+        },
+        "lodash.flatten": {
+            "version": "4.4.0",
+            "resolved": "https://registry.npmjs.org/lodash.flatten/-/lodash.flatten-4.4.0.tgz",
+            "integrity": "sha1-8xwiIlqWMtK7+OSt2+8kCqdlph8=",
+            "dev": true
+        },
+        "lodash.truncate": {
+            "version": "4.4.2",
+            "resolved": "https://registry.npmjs.org/lodash.truncate/-/lodash.truncate-4.4.2.tgz",
+            "integrity": "sha1-WjUNoLERO4N+z//VgSy+WNbq4ZM=",
+            "dev": true
+        },
        "log-symbols": {
            "version": "4.0.0",
            "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-4.0.0.tgz",
@@ -5052,13 +5126,13 @@
            "dev": true
        },
        "micromatch": {
-            "version": "4.0.2",
+            "version": "4.0.4",
-            "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.2.tgz",
+            "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.4.tgz",
-            "integrity": "sha512-y7FpHSbMUMoyPbYUSzO6PaZ6FyRnQOpHuKwbo1G+Knck95XVU4QAiKdGEnj5wwoS7PlOgthX/09u5iFJ+aYf5Q==",
+            "integrity": "sha512-pRmzw/XUcwXGpD9aI9q/0XOwLNygjETJ8y0ao0wdqprrzDa4YnxLcz7fQRZr8voh8V10kGhABbNcHVk5wHgWwg==",
            "dev": true,
            "requires": {
                "braces": "^3.0.1",
-                "picomatch": "^2.0.5"
+                "picomatch": "^2.2.3"
            }
        },
        "mime": {
@@ -5068,18 +5142,18 @@
            "dev": true
        },
        "mime-db": {
-            "version": "1.46.0",
+            "version": "1.47.0",
-            "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.46.0.tgz",
+            "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.47.0.tgz",
-            "integrity": "sha512-svXaP8UQRZ5K7or+ZmfNhg2xX3yKDMUzqadsSqi4NCH/KomcH75MAMYAGVlvXn4+b/xOPhS3I2uHKRUzvjY7BQ==",
+            "integrity": "sha512-QBmA/G2y+IfeS4oktet3qRZ+P5kPhCKRXxXnQEudYqUaEioAU1/Lq2us3D/t1Jfo4hE9REQPrbB7K5sOczJVIw==",
            "dev": true
        },
        "mime-types": {
-            "version": "2.1.29",
+            "version": "2.1.30",
-            "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.29.tgz",
+            "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.30.tgz",
-            "integrity": "sha512-Y/jMt/S5sR9OaqteJtslsFZKWOIIqMACsJSiHghlCAyhf7jfVYjKBmLiX8OgpWeW+fjJ2b+Az69aPFPkUOY6xQ==",
+            "integrity": "sha512-crmjA4bLtR8m9qLpHvgxSChT+XoSlZi8J4n/aIdn3z92e/U47Z0V/yl+Wh9W046GgFVAmoNR/fmdbZYcSSIUeg==",
            "dev": true,
            "requires": {
-                "mime-db": "1.46.0"
+                "mime-db": "1.47.0"
            }
        },
        "minimatch": {
@@ -5106,9 +5180,9 @@
            }
        },
        "mocha": {
-            "version": "8.3.0",
+            "version": "8.3.2",
-            "resolved": "https://registry.npmjs.org/mocha/-/mocha-8.3.0.tgz",
+            "resolved": "https://registry.npmjs.org/mocha/-/mocha-8.3.2.tgz",
-            "integrity": "sha512-TQqyC89V1J/Vxx0DhJIXlq9gbbL9XFNdeLQ1+JsnZsVaSOV1z3tWfw0qZmQJGQRIfkvZcs7snQnZnOCKoldq1Q==",
+            "integrity": "sha512-UdmISwr/5w+uXLPKspgoV7/RXZwKRTiTjJ2/AC5ZiEztIoOYdfKb19+9jNmEInzx5pBsCyJQzarAxqIGBNYJhg==",
            "dev": true,
            "requires": {
                "@ungap/promise-all-settled": "1.1.2",
@@ -5360,9 +5434,9 @@
            "dev": true
        },
        "picomatch": {
-            "version": "2.2.2",
+            "version": "2.2.3",
-            "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.2.2.tgz",
+            "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.2.3.tgz",
-            "integrity": "sha512-q0M/9eZHzmr0AulXyPwNfZjtwZ/RBZlbN3K3CErVrk50T2ASYI7Bye0EvekFY3IP1Nt2DHu0re+V2ZHIpMkuWg==",
+            "integrity": "sha512-KpELjfwcCDUb9PeigTs2mBJzXUPzAuP2oPcA989He8Rte0+YUAjw1JVedDhuTKPkHjSYzMN3npC9luThGYEKdg==",
            "dev": true
        },
        "prelude-ls": {
@@ -5396,9 +5470,9 @@
            "dev": true
        },
        "queue-microtask": {
-            "version": "1.2.2",
+            "version": "1.2.3",
-            "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.2.tgz",
+            "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
-            "integrity": "sha512-dB15eXv3p2jDlbOiNLyMabYg1/sXvppd8DP2J3EOCQ0AkuSXCW2tP7mnVouVLJKgUMY6yP0kcQDVpLCN13h4Xg==",
+            "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==",
            "dev": true
        },
        "randombytes": {
@@ -5501,9 +5575,9 @@
            }
        },
        "rollup": {
-            "version": "2.39.1",
+            "version": "2.45.2",
-            "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.39.1.tgz",
+            "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.45.2.tgz",
-            "integrity": "sha512-9rfr0Z6j+vE+eayfNVFr1KZ+k+jiUl2+0e4quZafy1x6SFCjzFspfRSO2ZZQeWeX9noeDTUDgg6eCENiEPFvQg==",
+            "integrity": "sha512-kRRU7wXzFHUzBIv0GfoFFIN3m9oteY4uAsKllIpQDId5cfnkWF2J130l+27dzDju0E6MScKiV0ZM5Bw8m4blYQ==",
            "dev": true,
            "requires": {
                "fsevents": "~2.3.1"
@@ -5525,9 +5599,9 @@
            "dev": true
        },
        "semver": {
-            "version": "7.3.4",
+            "version": "7.3.5",
-            "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.4.tgz",
+            "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.5.tgz",
-            "integrity": "sha512-tCfb2WLjqFAtXn4KEdxIhalnRtoKFN7nAwj0B3ZXCbQloV2tq5eDbcTmT68JJD3nRJq24/XgxtQKFIpQdtvmVw==",
+            "integrity": "sha512-PoeGJYh8HK4BTO/a9Tf6ZG3veo/A7ZVsYrSA6J8ny9nb3B1VrpkuN+z9OE5wfE5p6H4LchYZsegiQgbJD94ZFQ==",
            "requires": {
                "lru-cache": "^6.0.0"
            }
@@ -5615,9 +5689,9 @@
            }
        },
        "string-width": {
-            "version": "4.2.0",
+            "version": "4.2.2",
-            "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.0.tgz",
+            "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.2.tgz",
-            "integrity": "sha512-zUz5JD+tgqtuDjMhwIg5uFVV3dtqZ9yQJlZVfq4I01/K5Paj5UHj7VyrQOJvzawSVlKpObApbfD0Ed6yJc+1eg==",
+            "integrity": "sha512-XBJbT3N4JhVumXE0eoLU9DCjcaF92KLNqTmFCnG1pf8duUxFGwtP6AD6nkjw9a3IdiRtL3E2w3JDiE/xi3vOeA==",
            "dev": true,
            "requires": {
                "emoji-regex": "^8.0.0",
@@ -5650,21 +5724,24 @@
            }
        },
        "table": {
-            "version": "6.0.7",
+            "version": "6.5.1",
-            "resolved": "https://registry.npmjs.org/table/-/table-6.0.7.tgz",
+            "resolved": "https://registry.npmjs.org/table/-/table-6.5.1.tgz",
-            "integrity": "sha512-rxZevLGTUzWna/qBLObOe16kB2RTnnbhciwgPbMMlazz1yZGVEgnZK762xyVdVznhqxrfCeBMmMkgOOaPwjH7g==",
+            "integrity": "sha512-xGDXWTBJxahkzPQCsn1S9ESHEenU7TbMD5Iv4FeopXv/XwJyWatFjfbor+6ipI10/MNPXBYUamYukOrbPZ9L/w==",
            "dev": true,
            "requires": {
-                "ajv": "^7.0.2",
+                "ajv": "^8.0.1",
-                "lodash": "^4.17.20",
+                "lodash.clonedeep": "^4.5.0",
+                "lodash.flatten": "^4.4.0",
+                "lodash.truncate": "^4.4.2",
                "slice-ansi": "^4.0.0",
-                "string-width": "^4.2.0"
+                "string-width": "^4.2.0",
+                "strip-ansi": "^6.0.0"
            },
            "dependencies": {
                "ajv": {
-                    "version": "7.1.1",
+                    "version": "8.1.0",
-                    "resolved": "https://registry.npmjs.org/ajv/-/ajv-7.1.1.tgz",
+                    "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.1.0.tgz",
-                    "integrity": "sha512-ga/aqDYnUy/o7vbsRTFhhTsNeXiYb5JWDIcRIeZfwRNCefwjNTVYCGdGSUrEmiu3yDK3vFvNbgJxvrQW4JXrYQ==",
+                    "integrity": "sha512-B/Sk2Ix7A36fs/ZkuGLIR86EdjbgR6fsAcbx9lOP/QBSXujDNbVmIS/U4Itz5k8fPFDeVZl/zQ/gJW4Jrq6XjQ==",
                    "dev": true,
                    "requires": {
                        "fast-deep-equal": "^3.1.1",
@@ -5712,15 +5789,15 @@
            "dev": true
        },
        "tslib": {
-            "version": "2.1.0",
+            "version": "2.2.0",
-            "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.1.0.tgz",
+            "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.2.0.tgz",
-            "integrity": "sha512-hcVC3wYEziELGGmEEXue7D75zbwIIVUMWAVbHItGPx0ziyXxrOMQx4rQEVEV45Ut/1IotuEvwqPopzIOkDMf0A==",
+            "integrity": "sha512-gS9GVHRU+RGn5KQM2rllAlR3dU6m7AcpJKdtH8gFvQiC4Otgk98XnmMU+nZenHt/+VhnBPWwgrJsyrdcw6i23w==",
            "dev": true
        },
        "tsutils": {
-            "version": "3.20.0",
+            "version": "3.21.0",
-            "resolved": "https://registry.npmjs.org/tsutils/-/tsutils-3.20.0.tgz",
+            "resolved": "https://registry.npmjs.org/tsutils/-/tsutils-3.21.0.tgz",
-            "integrity": "sha512-RYbuQuvkhuqVeXweWT3tJLKOEJ/UUw9GjNEZGWdrLLlM+611o1gwLHBpxoFJKKl25fLprp2eVthtKs5JOrNeXg==",
+            "integrity": "sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==",
            "dev": true,
            "requires": {
                "tslib": "^1.8.1"
@@ -5750,9 +5827,9 @@
            }
        },
        "type-fest": {
-            "version": "0.8.1",
+            "version": "0.20.2",
-            "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.8.1.tgz",
+            "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz",
-            "integrity": "sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==",
+            "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==",
            "dev": true
        },
        "typed-rest-client": {
@@ -5766,9 +5843,9 @@
            }
        },
        "typescript": {
-            "version": "4.1.5",
+            "version": "4.2.4",
-            "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.1.5.tgz",
+            "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.2.4.tgz",
-            "integrity": "sha512-6OSu9PTIzmn9TCDiovULTnET6BgXtDYL4Gg4szY+cGsc3JP1dQL8qvE8kShTRx1NIw4Q9IBHlwODjkjWEtMUyA==",
+            "integrity": "sha512-V+evlYHZnQkaz8TRBuxTA92yZBPotr5H+WhQ7bD3hZUndx5tGOa1fuCgeSjxAzM1RiN5IzvadIXTVefuuwZCRg==",
            "dev": true
        },
        "typescript-formatter": {
@@ -5833,15 +5910,15 @@
            "dev": true
        },
        "v8-compile-cache": {
-            "version": "2.2.0",
+            "version": "2.3.0",
-            "resolved": "https://registry.npmjs.org/v8-compile-cache/-/v8-compile-cache-2.2.0.tgz",
+            "resolved": "https://registry.npmjs.org/v8-compile-cache/-/v8-compile-cache-2.3.0.tgz",
-            "integrity": "sha512-gTpR5XQNKFwOd4clxfnhaqvfqMpqEwr4tOtCyz4MtYZX2JYhfr1JvBFKdS+7K/9rfpZR3VLX+YWBbKoxCgS43Q==",
+            "integrity": "sha512-l8lCEmLcLYZh4nbunNZvQCJc5pv7+RCwa8q/LdUx8u7lsWvPDKmpodJAJNwkAhJC//dFY48KuIEmjtd4RViDrA==",
            "dev": true
        },
        "vsce": {
-            "version": "1.85.0",
+            "version": "1.87.1",
-            "resolved": "https://registry.npmjs.org/vsce/-/vsce-1.85.0.tgz",
+            "resolved": "https://registry.npmjs.org/vsce/-/vsce-1.87.1.tgz",
-            "integrity": "sha512-YVFwjXWvHRwk75mm3iL4Wr3auCdbBPTv2amtLf97ccqH0hkt0ZVBddu7iOs4HSEbSr9xiiaZwQHUsqMm6Ks0ag==",
+            "integrity": "sha512-3tSUWZl9AmhZrqy/UVUpdPODSzBiCGjIr/AMSSgF2PuFLSdrh+6kiOr2Ath7bpQEXOxf55hNgz3qdO5MuEJmww==",
            "dev": true,
            "requires": {
                "azure-devops-node-api": "^7.2.0",
@@ -5966,9 +6043,9 @@
            "integrity": "sha512-VGzh06oynbYa6JbTKUbxOEZN7CYEtWhN7DK5wfzUpeCJl8X8xZX39g2PVfpqXrIEduu7dcJgK007KgnX9tHNKA=="
        },
        "vscode-test": {
-            "version": "1.5.1",
+            "version": "1.5.2",
-            "resolved": "https://registry.npmjs.org/vscode-test/-/vscode-test-1.5.1.tgz",
+            "resolved": "https://registry.npmjs.org/vscode-test/-/vscode-test-1.5.2.tgz",
-            "integrity": "sha512-tDloz6euDne+GeUSglhufL0c2xhuYAPAT74hjsuGxfflALfXF9bYnJ7ehZEeVkr/ZnQEh/T8EBrfPL+m0h5qEQ==",
+            "integrity": "sha512-x9PVfKxF6EInH9iSFGQi0V8H5zIW1fC7RAer6yNQR6sy3WyOwlWkuT3I+wf75xW/cO53hxMi1aj/EvqQfDFOAg==",
            "dev": true,
            "requires": {
                "http-proxy-agent": "^4.0.1",
@@ -6058,9 +6135,9 @@
            "dev": true
        },
        "y18n": {
-            "version": "5.0.5",
+            "version": "5.0.8",
-            "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.5.tgz",
+            "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
-            "integrity": "sha512-hsRUr4FFrvhhRH12wOdfs38Gy7k2FFzB9qgN9v3aLykRq0dRcdcpz5C9FxdS2NuhOrI/628b/KSTJ3rwHysYSg==",
+            "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
            "dev": true
        },
        "yallist": {
diff --git a/editors/code/package.json b/editors/code/package.json
index fa5632f90..97d92e43c 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -653,6 +653,11 @@
                    "default": true,
                    "type": "boolean"
                },
+                "rust-analyzer.inlayHints.smallerHints": {
+                    "markdownDescription": "Whether inlay hints font size should be smaller than editor's font size.",
+                    "default": true,
+                    "type": "boolean"
+                },
                "rust-analyzer.lens.debug": {
                    "markdownDescription": "Whether to show `Debug` lens. Only applies when\n`#rust-analyzer.lens.enable#` is set.",
                    "default": true,
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 82f0a0566..03f7d7cc3 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -115,6 +115,7 @@ export class Config {
            typeHints: this.get<boolean>("inlayHints.typeHints"),
            parameterHints: this.get<boolean>("inlayHints.parameterHints"),
            chainingHints: this.get<boolean>("inlayHints.chainingHints"),
+            smallerHints: this.get<boolean>("inlayHints.smallerHints"),
            maxLength: this.get<null | number>("inlayHints.maxLength"),
        };
    }
diff --git a/editors/code/src/inlay_hints.ts b/editors/code/src/inlay_hints.ts
index 61db6b8d0..c23d6f738 100644
--- a/editors/code/src/inlay_hints.ts
+++ b/editors/code/src/inlay_hints.ts
@@ -5,6 +5,17 @@ import * as ra from './lsp_ext';
 import { Ctx, Disposable } from './ctx';
 import { sendRequestWithRetry, isRustDocument, RustDocument, RustEditor, sleep } from './util';
+interface InlayHintStyle {
+    decorationType: vscode.TextEditorDecorationType;
+    toDecoration(hint: ra.InlayHint, conv: lc.Protocol2CodeConverter): vscode.DecorationOptions;
+};
+interface InlayHintsStyles {
+    typeHints: InlayHintStyle;
+    paramHints: InlayHintStyle;
+    chainingHints: InlayHintStyle;
+}
 export function activateInlayHints(ctx: Ctx) {
    const maybeUpdater = {
@@ -19,6 +30,7 @@ export function activateInlayHints(ctx: Ctx) {
            await sleep(100);
            if (this.updater) {
+                this.updater.updateInlayHintsStyles();
                this.updater.syncCacheAndRenderHints();
            } else {
                this.updater = new HintsUpdater(ctx);
@@ -39,11 +51,7 @@ export function activateInlayHints(ctx: Ctx) {
    maybeUpdater.onConfigChange().catch(console.error);
 }
-const typeHints = createHintStyle("type");
+function createHintStyle(hintKind: "type" | "parameter" | "chaining", smallerHints: boolean): InlayHintStyle {
-const paramHints = createHintStyle("parameter");
-const chainingHints = createHintStyle("chaining");
-function createHintStyle(hintKind: "type" | "parameter" | "chaining") {
    // U+200C is a zero-width non-joiner to prevent the editor from forming a ligature
    // between code and type hints
    const [pos, render] = ({
@@ -61,7 +69,7 @@ function createHintStyle(hintKind: "type" | "parameter" | "chaining") {
                backgroundColor: bg,
                fontStyle: "normal",
                fontWeight: "normal",
-                textDecoration: ";font-size:smaller",
+                textDecoration: smallerHints ? ";font-size:smaller" : "none",
            },
        }),
        toDecoration(hint: ra.InlayHint, conv: lc.Protocol2CodeConverter): vscode.DecorationOptions {
@@ -73,9 +81,23 @@ function createHintStyle(hintKind: "type" | "parameter" | "chaining") {
    };
 }
+const smallHintsStyles = {
+    typeHints: createHintStyle("type", true),
+    paramHints: createHintStyle("parameter", true),
+    chainingHints: createHintStyle("chaining", true),
+};
+const biggerHintsStyles = {
+    typeHints: createHintStyle("type", false),
+    paramHints: createHintStyle("parameter", false),
+    chainingHints: createHintStyle("chaining", false),
+};
 class HintsUpdater implements Disposable {
    private sourceFiles = new Map<string, RustSourceFile>(); // map Uri -> RustSourceFile
    private readonly disposables: Disposable[] = [];
+    private pendingDisposeDecorations: undefined | InlayHintsStyles = undefined;
+    private inlayHintsStyles!: InlayHintsStyles;
    constructor(private readonly ctx: Ctx) {
        vscode.window.onDidChangeVisibleTextEditors(
@@ -100,6 +122,7 @@ class HintsUpdater implements Disposable {
            }
        ));
+        this.updateInlayHintsStyles();
        this.syncCacheAndRenderHints();
    }
@@ -114,6 +137,15 @@ class HintsUpdater implements Disposable {
        this.syncCacheAndRenderHints();
    }
+    updateInlayHintsStyles() {
+        const inlayHintsStyles = this.ctx.config.inlayHints.smallerHints ? smallHintsStyles : biggerHintsStyles;
+        if (inlayHintsStyles !== this.inlayHintsStyles) {
+            this.pendingDisposeDecorations = this.inlayHintsStyles;
+            this.inlayHintsStyles = inlayHintsStyles;
+        }
+    }
    syncCacheAndRenderHints() {
        this.sourceFiles.forEach((file, uri) => this.fetchHints(file).then(hints => {
            if (!hints) return;
@@ -161,12 +193,20 @@ class HintsUpdater implements Disposable {
    }
    private renderDecorations(editor: RustEditor, decorations: InlaysDecorations) {
+        const { typeHints, paramHints, chainingHints } = this.inlayHintsStyles;
+        if (this.pendingDisposeDecorations !== undefined) {
+            const { typeHints, paramHints, chainingHints } = this.pendingDisposeDecorations;
+            editor.setDecorations(typeHints.decorationType, []);
+            editor.setDecorations(paramHints.decorationType, []);
+            editor.setDecorations(chainingHints.decorationType, []);
+        }
        editor.setDecorations(typeHints.decorationType, decorations.type);
        editor.setDecorations(paramHints.decorationType, decorations.param);
        editor.setDecorations(chainingHints.decorationType, decorations.chaining);
    }
    private hintsToDecorations(hints: ra.InlayHint[]): InlaysDecorations {
+        const { typeHints, paramHints, chainingHints } = this.inlayHintsStyles;
        const decorations: InlaysDecorations = { type: [], param: [], chaining: [] };
        const conv = this.ctx.client.protocol2CodeConverter;
diff --git a/xtask/src/dist.rs b/xtask/src/dist.rs
index f2503f807..12a7fea1e 100644
--- a/xtask/src/dist.rs
+++ b/xtask/src/dist.rs
@@ -7,26 +7,31 @@ use std::{
 use anyhow::Result;
 use flate2::{write::GzEncoder, Compression};
-use xshell::{cmd, cp, mkdir_p, pushd, read_file, rm_rf, write_file};
+use xshell::{cmd, cp, mkdir_p, pushd, pushenv, read_file, rm_rf, write_file};
-use crate::{date_iso, project_root};
+use crate::{date_iso, flags, project_root};
-pub(crate) struct DistCmd {
+impl flags::Dist {
-    pub(crate) nightly: bool,
-    pub(crate) client_version: Option<String>,
-}
-impl DistCmd {
    pub(crate) fn run(self) -> Result<()> {
+        let stable =
+            std::env::var("GITHUB_REF").unwrap_or_default().as_str() == "refs/heads/release";
        let dist = project_root().join("dist");
        rm_rf(&dist)?;
        mkdir_p(&dist)?;
-        if let Some(version) = self.client_version {
+        if let Some(patch_version) = self.client_patch_version {
-            let release_tag = if self.nightly { "nightly".to_string() } else { date_iso()? };
+            let version = if stable {
+                format!("0.2.{}", patch_version)
+            } else {
+                // A hack to make VS Code prefer nightly over stable.
+                format!("0.3.{}", patch_version)
+            };
+            let release_tag = if stable { date_iso()? } else { "nightly".to_string() };
            dist_client(&version, &release_tag)?;
        }
-        dist_server()?;
+        let release_channel = if stable { "stable" } else { "nightly" };
+        dist_server(release_channel)?;
        Ok(())
    }
 }
@@ -39,7 +44,9 @@ fn dist_client(version: &str, release_tag: &str) -> Result<()> {
    patch
        .replace(r#""version": "0.4.0-dev""#, &format!(r#""version": "{}""#, version))
-        .replace(r#""releaseTag": null"#, &format!(r#""releaseTag": "{}""#, release_tag));
+        .replace(r#""releaseTag": null"#, &format!(r#""releaseTag": "{}""#, release_tag))
+        .replace(r#""$generated-start": false,"#, "")
+        .replace(",\n                \"$generated-end\": false", "");
    if nightly {
        patch.replace(
@@ -57,7 +64,8 @@ fn dist_client(version: &str, release_tag: &str) -> Result<()> {
    Ok(())
 }
-fn dist_server() -> Result<()> {
+fn dist_server(release_channel: &str) -> Result<()> {
+    let _e = pushenv("RUST_ANALYZER_CHANNEL", release_channel);
    let target = get_target();
    if target.contains("-linux-gnu") || target.contains("-linux-musl") {
        env::set_var("CC", "clang");
diff --git a/xtask/src/flags.rs b/xtask/src/flags.rs
index 4cd2b1ddb..f80a5dd16 100644
--- a/xtask/src/flags.rs
+++ b/xtask/src/flags.rs
@@ -37,8 +37,7 @@ xflags::xflags! {
            optional --dry-run
        }
        cmd dist {
-            optional --nightly
+            optional --client-patch-version version: String
-            optional --client version: String
        }
        cmd metrics {
            optional --dry-run
@@ -86,9 +85,6 @@ pub struct Install {
 }
 #[derive(Debug)]
-pub struct Lint;
-#[derive(Debug)]
 pub struct FuzzTests;
 #[derive(Debug)]
@@ -106,8 +102,7 @@ pub struct Promote {
 #[derive(Debug)]
 pub struct Dist {
-    pub nightly: bool,
+    pub client_patch_version: Option<String>,
-    pub client: Option<String>,
 }
 #[derive(Debug)]
diff --git a/xtask/src/main.rs b/xtask/src/main.rs
index 960927fc0..ce3353410 100644
--- a/xtask/src/main.rs
+++ b/xtask/src/main.rs
@@ -28,8 +28,6 @@ use std::{
 use walkdir::{DirEntry, WalkDir};
 use xshell::{cmd, cp, pushd, pushenv};
-use crate::dist::DistCmd;
 fn main() -> Result<()> {
    let _d = pushd(project_root())?;
@@ -44,9 +42,7 @@ fn main() -> Result<()> {
        flags::XtaskCmd::PreCache(cmd) => cmd.run(),
        flags::XtaskCmd::Release(cmd) => cmd.run(),
        flags::XtaskCmd::Promote(cmd) => cmd.run(),
-        flags::XtaskCmd::Dist(flags) => {
+        flags::XtaskCmd::Dist(cmd) => cmd.run(),
-            DistCmd { nightly: flags.nightly, client_version: flags.client }.run()
-        }
        flags::XtaskCmd::Metrics(cmd) => cmd.run(),
        flags::XtaskCmd::Bb(cmd) => {
            {
@@ -112,7 +108,7 @@ fn run_fuzzer() -> Result<()> {
 }
 fn date_iso() -> Result<String> {
-    let res = cmd!("date --iso --utc").read()?;
+    let res = cmd!("date -u +%Y-%m-%d").read()?;
    Ok(res)
 }
diff --git a/xtask/src/release.rs b/xtask/src/release.rs
index 22bb50467..452f351d0 100644
--- a/xtask/src/release.rs
+++ b/xtask/src/release.rs
@@ -10,7 +10,16 @@ impl flags::Release {
            cmd!("git switch release").run()?;
            cmd!("git fetch upstream --tags --force").run()?;
            cmd!("git reset --hard tags/nightly").run()?;
-            cmd!("git push").run()?;
+            // The `release` branch sometimes has a couple of cherry-picked
+            // commits for patch releases. If that's the case, just overwrite
+            // it. As we are setting `release` branch to an up-to-date `nightly`
+            // tag, this shouldn't be problematic in general.
+            //
+            // Note that, as we tag releases, we don't worry about "losing"
+            // commits -- they'll be kept alive by the tag. More generally, we
+            // don't care about historic releases all that much, it's fine even
+            // to delete old tags.
+            cmd!("git push --force").run()?;
        }
        codegen::docs()?;