6 files changed, 121 insertions, 48 deletions
diff --git a/crates/assists/src/utils/insert_use.rs b/crates/assists/src/utils/insert_use.rs
index 8dd4fe607..f6025c99a 100644
--- a/crates/assists/src/utils/insert_use.rs
+++ b/crates/assists/src/utils/insert_use.rs
@@ -4,13 +4,14 @@ use std::{
    iter::{self, successors},
 };
-use ast::{
+use itertools::{EitherOrBoth, Itertools};
-    edit::{AstNodeEdit, IndentLevel},
-    PathSegmentKind, VisibilityOwner,
-};
 use syntax::{
    algo,
-    ast::{self, make, AstNode},
+    ast::{
+        self,
+        edit::{AstNodeEdit, IndentLevel},
+        make, AstNode, PathSegmentKind, VisibilityOwner,
+    },
    InsertPosition, SyntaxElement, SyntaxNode,
 };
@@ -193,13 +194,13 @@ fn recursive_merge(
            false => None,
        })
        .collect::<Option<Vec<_>>>()?;
-    use_trees.sort_unstable_by(|a, b| path_cmp_opt(a.path(), b.path()));
+    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(|p| path_cmp_opt(p.path(), rhs_path.clone())) {
+        match use_trees.binary_search_by(|p| path_cmp_bin_search(p.path(), rhs_path.clone())) {
            Ok(idx) => {
                let lhs_t = &mut use_trees[idx];
                let lhs_path = lhs_t.path()?;
@@ -307,39 +308,77 @@ fn path_len(path: ast::Path) -> usize {
 /// Orders paths in the following way:
 /// the sole self token comes first, after that come uppercase identifiers, then lowercase identifiers
-// FIXME: rustfmt sort lowercase idents before uppercase, in general we want to have the same ordering rustfmt has
+// 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(a: &ast::Path, b: &ast::Path) -> Ordering {
+fn path_cmp_for_sort(a: Option<ast::Path>, b: Option<ast::Path>) -> Ordering {
-    match (path_is_self(a), path_is_self(b)) {
+    match (a, b) {
-        (true, true) => Ordering::Equal,
+        (None, None) => Ordering::Equal,
-        (true, false) => Ordering::Less,
+        (None, Some(_)) => Ordering::Less,
-        (false, true) => Ordering::Greater,
+        (Some(_), None) => Ordering::Greater,
-        (false, false) => {
+        (Some(ref a), Some(ref b)) => match (path_is_self(a), path_is_self(b)) {
-            let a = segment_iter(a);
+            (true, true) => Ordering::Equal,
-            let b = segment_iter(b);
+            (true, false) => Ordering::Less,
-            // cmp_by would be useful for us here but that is currently unstable
+            (false, true) => Ordering::Greater,
-            // cmp doesnt work due the lifetimes on text's return type
+            (false, false) => path_cmp_short(a, b),
-            a.zip(b)
+        },
-                .flat_map(|(seg, seg2)| seg.name_ref().zip(seg2.name_ref()))
-                .find_map(|(a, b)| match a.text().cmp(b.text()) {
-                    ord @ Ordering::Greater | ord @ Ordering::Less => Some(ord),
-                    Ordering::Equal => None,
-                })
-                .unwrap_or(Ordering::Equal)
-        }
    }
 }
-fn path_cmp_opt(a: Option<ast::Path>, b: Option<ast::Path>) -> Ordering {
+/// Path comparison func for binary searching for merging.
-    match (a, b) {
+fn path_cmp_bin_search(lhs: Option<ast::Path>, rhs: Option<ast::Path>) -> Ordering {
+    match (lhs, rhs) {
        (None, None) => Ordering::Equal,
        (None, Some(_)) => Ordering::Less,
        (Some(_), None) => Ordering::Greater,
-        (Some(a), Some(b)) => path_cmp(&a, &b),
+        (Some(ref a), Some(ref b)) => path_cmp_short(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.name_ref();
+    let b = b.name_ref();
+    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 MergeBehaviour {
@@ -389,7 +428,6 @@ impl ImportGroup {
            PathSegmentKind::Name(name) => match name.text().as_str() {
                "std" => ImportGroup::Std,
                "core" => ImportGroup::Std,
-                // FIXME: can be ThisModule as well
                _ => ImportGroup::ExternCrate,
            },
            PathSegmentKind::Type { .. } => unreachable!(),
@@ -415,30 +453,30 @@ fn find_insert_position(
        .as_syntax_node()
        .children()
        .filter_map(|node| ast::Use::cast(node.clone()).zip(Some(node)))
-        .flat_map(|(use_, node)| use_.use_tree().and_then(|tree| tree.path()).zip(Some(node)));
+        .flat_map(|(use_, node)| {
+            let tree = use_.use_tree()?;
+            let path = tree.path()?;
+            let has_tl = tree.use_tree_list().is_some();
+            Some((path, has_tl, node))
+        });
    // Iterator that discards anything thats not in the required grouping
    // This implementation allows the user to rearrange their import groups as this only takes the first group that fits
    let group_iter = path_node_iter
        .clone()
-        .skip_while(|(path, _)| ImportGroup::new(path) != group)
+        .skip_while(|(path, ..)| ImportGroup::new(path) != group)
-        .take_while(|(path, _)| ImportGroup::new(path) == group);
+        .take_while(|(path, ..)| ImportGroup::new(path) == group);
-    let segments = segment_iter(&insert_path);
    // 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 =
+    let post_insert = group_iter.inspect(|(.., node)| last = Some(node.clone())).find(
-        group_iter.inspect(|(_, node)| last = Some(node.clone())).find(|(path, _)| {
+        |&(ref path, has_tl, _)| {
-            let check_segments = segment_iter(&path);
+            use_tree_path_cmp(&insert_path, false, path, has_tl) != Ordering::Greater
-            segments
+        },
-                .clone()
+    );
-                .zip(check_segments)
-                .flat_map(|(seg, seg2)| seg.name_ref().zip(seg2.name_ref()))
-                .all(|(l, r)| l.text() <= r.text())
-        });
    match post_insert {
        // insert our import before that element
-        Some((_, node)) => (InsertPosition::Before(node.into()), AddBlankLine::After),
+        Some((.., node)) => (InsertPosition::Before(node.into()), AddBlankLine::After),
        // there is no element after our new import, so append it to the end of the group
        None => match last {
            Some(node) => (InsertPosition::After(node.into()), AddBlankLine::Before),
@@ -448,10 +486,10 @@ fn find_insert_position(
                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()))
+                    .inspect(|(.., node)| last = Some(node.clone()))
-                    .find(|(p, _)| ImportGroup::new(p) > group);
+                    .find(|(p, ..)| ImportGroup::new(p) > group);
                match post_group {
-                    Some((_, node)) => {
+                    Some((.., node)) => {
                        (InsertPosition::Before(node.into()), AddBlankLine::AfterTwice)
                    }
                    // there is no such group, so append after the last one
@@ -844,7 +882,6 @@ use foo::bar::baz::Qux;",
    }
    #[test]
-    #[ignore] // FIXME: Order changes when switching lhs and rhs
    fn skip_merge_last_too_long2() {
        check_last(
            "foo::bar::baz::Qux",
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 42e1ad376..0ab4c37bf 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -38,6 +38,7 @@ pub struct Config {
    pub cargo: CargoConfig,
    pub rustfmt: RustfmtConfig,
    pub flycheck: Option<FlycheckConfig>,
+    pub runnables: RunnablesConfig,
    pub inlay_hints: InlayHintsConfig,
    pub completion: CompletionConfig,
@@ -124,6 +125,15 @@ pub enum RustfmtConfig {
    CustomCommand { command: String, args: Vec<String> },
 }
+/// Configuration for runnable items, such as `main` function or tests.
+#[derive(Debug, Clone, Default)]
+pub struct RunnablesConfig {
+    /// Custom command to be executed instead of `cargo` for runnables.
+    pub override_cargo: Option<String>,
+    /// Additional arguments for the `cargo`, e.g. `--release`.
+    pub cargo_extra_args: Vec<String>,
+}
 #[derive(Debug, Clone, Default)]
 pub struct ClientCapsConfig {
    pub location_link: bool,
@@ -164,6 +174,7 @@ impl Config {
                extra_args: Vec::new(),
                features: Vec::new(),
            }),
+            runnables: RunnablesConfig::default(),
            inlay_hints: InlayHintsConfig {
                type_hints: true,
@@ -220,6 +231,10 @@ impl Config {
            load_out_dirs_from_check: data.cargo_loadOutDirsFromCheck,
            target: data.cargo_target.clone(),
        };
+        self.runnables = RunnablesConfig {
+            override_cargo: data.runnables_overrideCargo,
+            cargo_extra_args: data.runnables_cargoExtraArgs,
+        };
        self.proc_macro_srv = if data.procMacro_enable {
            std::env::current_exe().ok().map(|path| (path, vec!["proc-macro".into()]))
@@ -474,6 +489,9 @@ config_data! {
        notifications_cargoTomlNotFound: bool      = true,
        procMacro_enable: bool                     = false,
+        runnables_overrideCargo: Option<String> = None,
+        runnables_cargoExtraArgs: Vec<String>   = Vec::new(),
        rustfmt_extraArgs: Vec<String>               = Vec::new(),
        rustfmt_overrideCommand: Option<Vec<String>> = None,
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index afcec63ad..e970abb7c 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -491,6 +491,7 @@ pub(crate) fn handle_runnables(
    }
    // Add `cargo check` and `cargo test` for all targets of the whole package
+    let config = &snap.config.runnables;
    match cargo_spec {
        Some(spec) => {
            for &cmd in ["check", "test"].iter() {
@@ -500,12 +501,14 @@ pub(crate) fn handle_runnables(
                    kind: lsp_ext::RunnableKind::Cargo,
                    args: lsp_ext::CargoRunnable {
                        workspace_root: Some(spec.workspace_root.clone().into()),
+                        override_cargo: config.override_cargo.clone(),
                        cargo_args: vec![
                            cmd.to_string(),
                            "--package".to_string(),
                            spec.package.clone(),
                            "--all-targets".to_string(),
                        ],
+                        cargo_extra_args: config.cargo_extra_args.clone(),
                        executable_args: Vec::new(),
                        expect_test: None,
                    },
@@ -519,7 +522,9 @@ pub(crate) fn handle_runnables(
                kind: lsp_ext::RunnableKind::Cargo,
                args: lsp_ext::CargoRunnable {
                    workspace_root: None,
+                    override_cargo: config.override_cargo.clone(),
                    cargo_args: vec!["check".to_string(), "--workspace".to_string()],
+                    cargo_extra_args: config.cargo_extra_args.clone(),
                    executable_args: Vec::new(),
                    expect_test: None,
                },
diff --git a/crates/rust-analyzer/src/lsp_ext.rs b/crates/rust-analyzer/src/lsp_ext.rs
index 43ff191da..fee0bb69c 100644
--- a/crates/rust-analyzer/src/lsp_ext.rs
+++ b/crates/rust-analyzer/src/lsp_ext.rs
@@ -171,10 +171,14 @@ pub enum RunnableKind {
 #[derive(Deserialize, Serialize, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct CargoRunnable {
+    // command to be executed instead of cargo
+    pub override_cargo: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub workspace_root: Option<PathBuf>,
    // command, --package and --lib stuff
    pub cargo_args: Vec<String>,
+    // user-specified additional cargo args, like `--release`.
+    pub cargo_extra_args: Vec<String>,
    // stuff after --
    pub executable_args: Vec<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 59e780b7d..aeacde0f7 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -740,6 +740,7 @@ pub(crate) fn runnable(
    file_id: FileId,
    runnable: Runnable,
 ) -> Result<lsp_ext::Runnable> {
+    let config = &snap.config.runnables;
    let spec = CargoTargetSpec::for_file(snap, file_id)?;
    let workspace_root = spec.as_ref().map(|it| it.workspace_root.clone());
    let target = spec.as_ref().map(|s| s.target.clone());
@@ -754,7 +755,9 @@ pub(crate) fn runnable(
        kind: lsp_ext::RunnableKind::Cargo,
        args: lsp_ext::CargoRunnable {
            workspace_root: workspace_root.map(|it| it.into()),
+            override_cargo: config.override_cargo.clone(),
            cargo_args,
+            cargo_extra_args: config.cargo_extra_args.clone(),
            executable_args,
            expect_test: None,
        },
diff --git a/crates/rust-analyzer/tests/rust-analyzer/main.rs b/crates/rust-analyzer/tests/rust-analyzer/main.rs
index 06726f957..e51eb2626 100644
--- a/crates/rust-analyzer/tests/rust-analyzer/main.rs
+++ b/crates/rust-analyzer/tests/rust-analyzer/main.rs
@@ -107,6 +107,8 @@ fn main() {}
            "args": {
              "cargoArgs": ["test", "--package", "foo", "--test", "spam"],
              "executableArgs": ["test_eggs", "--exact", "--nocapture"],
+              "cargoExtraArgs": [],
+              "overrideCargo": null,
              "workspaceRoot": server.path().join("foo")
            },
            "kind": "cargo",
@@ -127,6 +129,8 @@ fn main() {}
            "args": {
              "cargoArgs": ["check", "--package", "foo", "--all-targets"],
              "executableArgs": [],
+              "cargoExtraArgs": [],
+              "overrideCargo": null,
              "workspaceRoot": server.path().join("foo")
            },
            "kind": "cargo",
@@ -136,6 +140,8 @@ fn main() {}
            "args": {
              "cargoArgs": ["test", "--package", "foo", "--all-targets"],
              "executableArgs": [],
+              "cargoExtraArgs": [],
+              "overrideCargo": null,
              "workspaceRoot": server.path().join("foo")
            },
            "kind": "cargo",