14 files changed, 791 insertions, 317 deletions

diff --git a/crates/ide_assists/src/handlers/convert_comment_block.rs b/crates/ide_assists/src/handlers/convert_comment_block.rs
new file mode 100644
index 000000000..cdc45fc42
--- /dev/null
+++ b/crates/ide_assists/src/handlers/convert_comment_block.rs
@@ -0,0 +1,419 @@
+use itertools::Itertools;
+use std::convert::identity;
+use syntax::{
+    ast::{
+        self,
+        edit::IndentLevel,
+        Comment, CommentKind,
+        CommentPlacement::{Inner, Outer},
+        CommentShape::{self, Block, Line},
+        Whitespace,
+    },
+    AstToken, Direction, SyntaxElement, TextRange,
+};
+
+use crate::{AssistContext, AssistId, AssistKind, Assists};
+
+/// Assist: line_to_block
+///
+/// Converts comments between block and single-line form
+///
+/// ```
+///    // Multi-line
+///    // comment
+/// ```
+/// ->
+/// ```
+///   /**
+///   Multi-line
+///   comment
+///   */
+/// ```
+pub(crate) fn convert_comment_block(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    if let Some(comment) = ctx.find_token_at_offset::<ast::Comment>() {
+        // Only allow comments which are alone on their line
+        if let Some(prev) = comment.syntax().prev_token() {
+            if Whitespace::cast(prev).filter(|w| w.text().contains('\n')).is_none() {
+                return None;
+            }
+        }
+
+        return match comment.kind().shape {
+            ast::CommentShape::Block => block_to_line(acc, comment),
+            ast::CommentShape::Line => line_to_block(acc, comment),
+        };
+    }
+
+    return None;
+}
+
+fn block_to_line(acc: &mut Assists, comment: ast::Comment) -> Option<()> {
+    let target = comment.syntax().text_range();
+
+    acc.add(
+        AssistId("block_to_line", AssistKind::RefactorRewrite),
+        "Replace block comment with line comments",
+        target,
+        |edit| {
+            let indentation = IndentLevel::from_token(comment.syntax());
+            let line_prefix =
+                comment_kind_prefix(CommentKind { shape: CommentShape::Line, ..comment.kind() });
+
+            let text = comment.text();
+            let text = &text[comment.prefix().len()..(text.len() - "*/".len())].trim();
+
+            let lines = text.lines().peekable();
+
+            let indent_spaces = indentation.to_string();
+            let output = lines
+                .map(|l| l.trim_start_matches(&indent_spaces))
+                .map(|l| {
+                    // Don't introduce trailing whitespace
+                    if l.is_empty() {
+                        line_prefix.to_string()
+                    } else {
+                        format!("{} {}", line_prefix, l.trim_start_matches(&indent_spaces))
+                    }
+                })
+                .join(&format!("\n{}", indent_spaces));
+
+            edit.replace(target, output)
+        },
+    )
+}
+
+fn line_to_block(acc: &mut Assists, comment: ast::Comment) -> Option<()> {
+    // Find all the comments we'll be collapsing into a block
+    let comments = relevant_line_comments(&comment);
+
+    // Establish the target of our edit based on the comments we found
+    let target = TextRange::new(
+        comments[0].syntax().text_range().start(),
+        comments.last().unwrap().syntax().text_range().end(),
+    );
+
+    acc.add(
+        AssistId("line_to_block", AssistKind::RefactorRewrite),
+        "Replace line comments with a single block comment",
+        target,
+        |edit| {
+            // We pick a single indentation level for the whole block comment based on the
+            // comment where the assist was invoked. This will be prepended to the
+            // contents of each line comment when they're put into the block comment.
+            let indentation = IndentLevel::from_token(&comment.syntax());
+
+            let block_comment_body =
+                comments.into_iter().map(|c| line_comment_text(indentation, c)).join("\n");
+
+            let block_prefix =
+                comment_kind_prefix(CommentKind { shape: CommentShape::Block, ..comment.kind() });
+
+            let output =
+                format!("{}\n{}\n{}*/", block_prefix, block_comment_body, indentation.to_string());
+
+            edit.replace(target, output)
+        },
+    )
+}
+
+/// The line -> block assist can  be invoked from anywhere within a sequence of line comments.
+/// relevant_line_comments crawls backwards and forwards finding the complete sequence of comments that will
+/// be joined.
+fn relevant_line_comments(comment: &ast::Comment) -> Vec<Comment> {
+    // The prefix identifies the kind of comment we're dealing with
+    let prefix = comment.prefix();
+    let same_prefix = |c: &ast::Comment| c.prefix() == prefix;
+
+    // These tokens are allowed to exist between comments
+    let skippable = |not: &SyntaxElement| {
+        not.clone()
+            .into_token()
+            .and_then(Whitespace::cast)
+            .map(|w| !w.spans_multiple_lines())
+            .unwrap_or(false)
+    };
+
+    // Find all preceding comments (in reverse order) that have the same prefix
+    let prev_comments = comment
+        .syntax()
+        .siblings_with_tokens(Direction::Prev)
+        .filter(|s| !skippable(s))
+        .map(|not| not.into_token().and_then(Comment::cast).filter(same_prefix))
+        .take_while(|opt_com| opt_com.is_some())
+        .filter_map(identity)
+        .skip(1); // skip the first element so we don't duplicate it in next_comments
+
+    let next_comments = comment
+        .syntax()
+        .siblings_with_tokens(Direction::Next)
+        .filter(|s| !skippable(s))
+        .map(|not| not.into_token().and_then(Comment::cast).filter(same_prefix))
+        .take_while(|opt_com| opt_com.is_some())
+        .filter_map(identity);
+
+    let mut comments: Vec<_> = prev_comments.collect();
+    comments.reverse();
+    comments.extend(next_comments);
+    comments
+}
+
+// Line comments usually begin with a single space character following the prefix as seen here:
+//^
+// But comments can also include indented text:
+//    > Hello there
+//
+// We handle this by stripping *AT MOST* one space character from the start of the line
+// This has its own problems because it can cause alignment issues:
+//
+//              /*
+// a      ----> a
+//b       ----> b
+//              */
+//
+// But since such comments aren't idiomatic we're okay with this.
+fn line_comment_text(indentation: IndentLevel, comm: ast::Comment) -> String {
+    let contents_without_prefix = comm.text().strip_prefix(comm.prefix()).unwrap();
+    let contents = contents_without_prefix.strip_prefix(' ').unwrap_or(contents_without_prefix);
+
+    // Don't add the indentation if the line is empty
+    if contents.is_empty() {
+        contents.to_owned()
+    } else {
+        indentation.to_string() + &contents
+    }
+}
+
+fn comment_kind_prefix(ck: ast::CommentKind) -> &'static str {
+    match (ck.shape, ck.doc) {
+        (Line, Some(Inner)) => "//!",
+        (Line, Some(Outer)) => "///",
+        (Line, None) => "//",
+        (Block, Some(Inner)) => "/*!",
+        (Block, Some(Outer)) => "/**",
+        (Block, None) => "/*",
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable};
+
+    use super::*;
+
+    #[test]
+    fn single_line_to_block() {
+        check_assist(
+            convert_comment_block,
+            r#"
+// line$0 comment
+fn main() {
+    foo();
+}
+"#,
+            r#"
+/*
+line comment
+*/
+fn main() {
+    foo();
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn single_line_to_block_indented() {
+        check_assist(
+            convert_comment_block,
+            r#"
+fn main() {
+    // line$0 comment
+    foo();
+}
+"#,
+            r#"
+fn main() {
+    /*
+    line comment
+    */
+    foo();
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn multiline_to_block() {
+        check_assist(
+            convert_comment_block,
+            r#"
+fn main() {
+    // above
+    // line$0 comment
+    //
+    // below
+    foo();
+}
+"#,
+            r#"
+fn main() {
+    /*
+    above
+    line comment
+
+    below
+    */
+    foo();
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn end_of_line_to_block() {
+        check_assist_not_applicable(
+            convert_comment_block,
+            r#"
+fn main() {
+    foo(); // end-of-line$0 comment
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn single_line_different_kinds() {
+        check_assist(
+            convert_comment_block,
+            r#"
+fn main() {
+    /// different prefix
+    // line$0 comment
+    // below
+    foo();
+}
+"#,
+            r#"
+fn main() {
+    /// different prefix
+    /*
+    line comment
+    below
+    */
+    foo();
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn single_line_separate_chunks() {
+        check_assist(
+            convert_comment_block,
+            r#"
+fn main() {
+    // different chunk
+
+    // line$0 comment
+    // below
+    foo();
+}
+"#,
+            r#"
+fn main() {
+    // different chunk
+
+    /*
+    line comment
+    below
+    */
+    foo();
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn doc_block_comment_to_lines() {
+        check_assist(
+            convert_comment_block,
+            r#"
+/**
+ hi$0 there
+*/
+"#,
+            r#"
+/// hi there
+"#,
+        );
+    }
+
+    #[test]
+    fn block_comment_to_lines() {
+        check_assist(
+            convert_comment_block,
+            r#"
+/*
+ hi$0 there
+*/
+"#,
+            r#"
+// hi there
+"#,
+        );
+    }
+
+    #[test]
+    fn inner_doc_block_to_lines() {
+        check_assist(
+            convert_comment_block,
+            r#"
+/*!
+ hi$0 there
+*/
+"#,
+            r#"
+//! hi there
+"#,
+        );
+    }
+
+    #[test]
+    fn block_to_lines_indent() {
+        check_assist(
+            convert_comment_block,
+            r#"
+fn main() {
+    /*!
+    hi$0 there
+
+    ```
+      code_sample
+    ```
+    */
+}
+"#,
+            r#"
+fn main() {
+    //! hi there
+    //!
+    //! ```
+    //!   code_sample
+    //! ```
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn end_of_line_block_to_line() {
+        check_assist_not_applicable(
+            convert_comment_block,
+            r#"
+fn main() {
+    foo(); /* end-of-line$0 comment */
+}
+"#,
+        );
+    }
+}
diff --git a/crates/ide_assists/src/lib.rs b/crates/ide_assists/src/lib.rs
index 53542d433..9c8148462 100644
--- a/crates/ide_assists/src/lib.rs
+++ b/crates/ide_assists/src/lib.rs
@@ -115,6 +115,7 @@ mod handlers {
     mod auto_import;
     mod change_visibility;
     mod convert_integer_literal;
+    mod convert_comment_block;
     mod early_return;
     mod expand_glob_import;
     mod extract_function;
@@ -178,6 +179,7 @@ mod handlers {
             auto_import::auto_import,
             change_visibility::change_visibility,
             convert_integer_literal::convert_integer_literal,
+            convert_comment_block::convert_comment_block,
             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/proc_macro_srv/src/rustc_server.rs b/crates/proc_macro_srv/src/rustc_server.rs
index a8504f762..952b4a97f 100644
--- a/crates/proc_macro_srv/src/rustc_server.rs
+++ b/crates/proc_macro_srv/src/rustc_server.rs
@@ -14,7 +14,6 @@ use std::collections::HashMap;
 use std::hash::Hash;
 use std::iter::FromIterator;
 use std::ops::Bound;
-use std::str::FromStr;
 use std::{ascii, vec::IntoIter};
 
 type Group = tt::Subtree;
@@ -278,6 +277,42 @@ impl server::FreeFunctions for Rustc {
     }
 }
 
+fn subtree_replace_token_ids_with_unspecified(subtree: tt::Subtree) -> tt::Subtree {
+    tt::Subtree {
+        delimiter: subtree.delimiter.map(|d| tt::Delimiter { id: tt::TokenId::unspecified(), ..d }),
+        token_trees: subtree
+            .token_trees
+            .into_iter()
+            .map(|t| token_tree_replace_token_ids_with_unspecified(t))
+            .collect(),
+    }
+}
+
+fn token_tree_replace_token_ids_with_unspecified(tt: tt::TokenTree) -> tt::TokenTree {
+    match tt {
+        tt::TokenTree::Leaf(leaf) => {
+            tt::TokenTree::Leaf(leaf_replace_token_ids_with_unspecified(leaf))
+        }
+        tt::TokenTree::Subtree(subtree) => {
+            tt::TokenTree::Subtree(subtree_replace_token_ids_with_unspecified(subtree))
+        }
+    }
+}
+
+fn leaf_replace_token_ids_with_unspecified(leaf: tt::Leaf) -> tt::Leaf {
+    match leaf {
+        tt::Leaf::Literal(lit) => {
+            tt::Leaf::Literal(tt::Literal { id: tt::TokenId::unspecified(), ..lit })
+        }
+        tt::Leaf::Punct(punct) => {
+            tt::Leaf::Punct(tt::Punct { id: tt::TokenId::unspecified(), ..punct })
+        }
+        tt::Leaf::Ident(ident) => {
+            tt::Leaf::Ident(tt::Ident { id: tt::TokenId::unspecified(), ..ident })
+        }
+    }
+}
+
 impl server::TokenStream for Rustc {
     fn new(&mut self) -> Self::TokenStream {
         Self::TokenStream::new()
@@ -287,7 +322,8 @@ impl server::TokenStream for Rustc {
         stream.is_empty()
     }
     fn from_str(&mut self, src: &str) -> Self::TokenStream {
-        Self::TokenStream::from_str(src).expect("cannot parse string")
+        let (subtree, _) = mbe::parse_to_token_tree(src).expect("cannot parse string");
+        TokenStream::with_subtree(subtree_replace_token_ids_with_unspecified(subtree))
     }
     fn to_string(&mut self, stream: &Self::TokenStream) -> String {
         stream.to_string()
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index b881cc229..8789f0852 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -24,7 +24,7 @@ jod-thread = "0.1.0"
 log = "0.4.8"
 lsp-types = { version = "0.88.0", features = ["proposed"] }
 parking_lot = "0.11.0"
-pico-args = "0.4.0"
+xflags = "0.1.2"
 oorandom = "11.1.2"
 rustc-hash = "1.1.0"
 serde = { version = "1.0.106", features = ["derive"] }
diff --git a/crates/rust-analyzer/src/bin/args.rs b/crates/rust-analyzer/src/bin/args.rs
deleted file mode 100644
index 164d94a30..000000000
--- a/crates/rust-analyzer/src/bin/args.rs
+++ /dev/null
@@ -1,274 +0,0 @@
-//! Command like parsing for rust-analyzer.
-//!
-//! If run started args, we run the LSP server loop. With a subcommand, we do a
-//! one-time batch processing.
-
-use std::{env, path::PathBuf};
-
-use anyhow::{bail, format_err, Result};
-use ide_ssr::{SsrPattern, SsrRule};
-use pico_args::Arguments;
-use rust_analyzer::cli::{AnalysisStatsCmd, BenchCmd, BenchWhat, Position, Verbosity};
-use vfs::AbsPathBuf;
-
-pub(crate) struct Args {
-    pub(crate) verbosity: Verbosity,
-    pub(crate) log_file: Option<PathBuf>,
-    pub(crate) no_buffering: bool,
-    pub(crate) command: Command,
-    #[allow(unused)]
-    pub(crate) wait_dbg: bool,
-}
-
-pub(crate) enum Command {
-    Parse { no_dump: bool },
-    Symbols,
-    Highlight { rainbow: bool },
-    AnalysisStats(AnalysisStatsCmd),
-    Bench(BenchCmd),
-    Diagnostics { path: PathBuf, load_output_dirs: bool, with_proc_macro: bool },
-    Ssr { rules: Vec<SsrRule> },
-    StructuredSearch { debug_snippet: Option<String>, patterns: Vec<SsrPattern> },
-    ProcMacro,
-    RunServer,
-    PrintConfigSchema,
-    Version,
-    Help,
-}
-
-const HELP: &str = "\
-rust-analyzer
-
-USAGE:
-    rust-analyzer [FLAGS] [COMMAND] [COMMAND_OPTIONS]
-
-FLAGS:
-    --version         Print version
-    -h, --help        Print this help
-
-    -v,  --verbose
-    -vv, --spammy
-    -q,  --quiet      Set verbosity
-
-    --print-config-schema
-                      Dump a LSP config JSON schema
-    --log-file <PATH> Log to the specified file instead of stderr
-    --no-log-buffering
-                      Flush log records to the file immediately
-
-    --wait-dbg        Wait until a debugger is attached to.
-                      The flag is valid for debug builds only
-
-ENVIRONMENTAL VARIABLES:
-    RA_LOG            Set log filter in env_logger format
-    RA_PROFILE        Enable hierarchical profiler
-    RA_WAIT_DBG       If set acts like a --wait-dbg flag
-
-COMMANDS:
-
-not specified         Launch LSP server
-
-parse < main.rs       Parse tree
-    --no-dump         Suppress printing
-
-symbols < main.rs     Parse input an print the list of symbols
-
-highlight < main.rs   Highlight input as html
-    --rainbow         Enable rainbow highlighting of identifiers
-
-analysis-stats <PATH> Batch typecheck project and print summary statistics
-    <PATH>            Directory with Cargo.toml
-    --randomize       Randomize order in which crates, modules, and items are processed
-    --parallel        Run type inference in parallel
-    --memory-usage    Collect memory usage statistics
-    -o, --only <PATH> Only analyze items matching this path
-    --with-deps       Also analyze all dependencies
-    --load-output-dirs
-                      Load OUT_DIR values by running `cargo check` before analysis
-    --with-proc-macro Use proc-macro-srv for proc-macro expanding
-
-analysis-bench <PATH> Benchmark specific analysis operation
-    <PATH>            Directory with Cargo.toml
-    --highlight <PATH>
-                      Compute syntax highlighting for this file
-    --complete <PATH:LINE:COLUMN>
-                      Compute completions at this location
-    --goto-def <PATH:LINE:COLUMN>
-                      Compute goto definition at this location
-    --memory-usage    Collect memory usage statistics
-    --load-output-dirs
-                      Load OUT_DIR values by running `cargo check` before analysis
-    --with-proc-macro Use proc-macro-srv for proc-macro expanding
-
-diagnostics <PATH>
-    <PATH>            Directory with Cargo.toml
-    --load-output-dirs
-                      Load OUT_DIR values by running `cargo check` before analysis
-    --with-proc-macro Use proc-macro-srv for proc-macro expanding
-
-ssr [RULE...]
-    <RULE>            A structured search replace rule (`$a.foo($b) ==> bar($a, $b)`)
-
-search [PATTERN..]
-    <PATTERN>         A structured search replace pattern (`$a.foo($b)`)
-    --debug <snippet> Prints debug information for any nodes with source exactly
-                      equal to <snippet>
-";
-
-impl Args {
-    pub(crate) fn parse() -> Result<Args> {
-        let mut matches = Arguments::from_env();
-
-        if matches.contains("--version") {
-            finish_args(matches)?;
-            return Ok(Args {
-                verbosity: Verbosity::Normal,
-                log_file: None,
-                command: Command::Version,
-                no_buffering: false,
-                wait_dbg: false,
-            });
-        }
-
-        let verbosity = match (
-            matches.contains(["-vv", "--spammy"]),
-            matches.contains(["-v", "--verbose"]),
-            matches.contains(["-q", "--quiet"]),
-        ) {
-            (true, _, true) => bail!("Invalid flags: -q conflicts with -vv"),
-            (true, _, false) => Verbosity::Spammy,
-            (false, false, false) => Verbosity::Normal,
-            (false, false, true) => Verbosity::Quiet,
-            (false, true, false) => Verbosity::Verbose,
-            (false, true, true) => bail!("Invalid flags: -q conflicts with -v"),
-        };
-        let log_file = matches.opt_value_from_str("--log-file")?;
-        let no_buffering = matches.contains("--no-log-buffering");
-        let wait_dbg = matches.contains("--wait-dbg");
-
-        if matches.contains(["-h", "--help"]) {
-            eprintln!("{}", HELP);
-            return Ok(Args {
-                verbosity,
-                log_file: None,
-                command: Command::Help,
-                no_buffering,
-                wait_dbg,
-            });
-        }
-
-        if matches.contains("--print-config-schema") {
-            return Ok(Args {
-                verbosity,
-                log_file,
-                command: Command::PrintConfigSchema,
-                no_buffering,
-                wait_dbg,
-            });
-        }
-
-        let subcommand = match matches.subcommand()? {
-            Some(it) => it,
-            None => {
-                finish_args(matches)?;
-                return Ok(Args {
-                    verbosity,
-                    log_file,
-                    command: Command::RunServer,
-                    no_buffering,
-                    wait_dbg,
-                });
-            }
-        };
-        let command = match subcommand.as_str() {
-            "parse" => Command::Parse { no_dump: matches.contains("--no-dump") },
-            "symbols" => Command::Symbols,
-            "highlight" => Command::Highlight { rainbow: matches.contains("--rainbow") },
-            "analysis-stats" => Command::AnalysisStats(AnalysisStatsCmd {
-                randomize: matches.contains("--randomize"),
-                parallel: matches.contains("--parallel"),
-                memory_usage: matches.contains("--memory-usage"),
-                only: matches.opt_value_from_str(["-o", "--only"])?,
-                with_deps: matches.contains("--with-deps"),
-                load_output_dirs: matches.contains("--load-output-dirs"),
-                with_proc_macro: matches.contains("--with-proc-macro"),
-                path: matches
-                    .opt_free_from_str()?
-                    .ok_or_else(|| format_err!("expected positional argument"))?,
-            }),
-            "analysis-bench" => Command::Bench(BenchCmd {
-                what: {
-                    let highlight_path: Option<String> =
-                        matches.opt_value_from_str("--highlight")?;
-                    let complete_path: Option<Position> =
-                        matches.opt_value_from_str("--complete")?;
-                    let goto_def_path: Option<Position> =
-                        matches.opt_value_from_str("--goto-def")?;
-                    match (highlight_path, complete_path, goto_def_path) {
-                            (Some(path), None, None) => {
-                                let path = env::current_dir().unwrap().join(path);
-                                BenchWhat::Highlight { path: AbsPathBuf::assert(path) }
-                            }
-                            (None, Some(position), None) => BenchWhat::Complete(position),
-                            (None, None, Some(position)) => BenchWhat::GotoDef(position),
-                            _ => panic!(
-                                "exactly one of  `--highlight`, `--complete` or `--goto-def` must be set"
-                            ),
-                        }
-                },
-                memory_usage: matches.contains("--memory-usage"),
-                load_output_dirs: matches.contains("--load-output-dirs"),
-                with_proc_macro: matches.contains("--with-proc-macro"),
-                path: matches
-                    .opt_free_from_str()?
-                    .ok_or_else(|| format_err!("expected positional argument"))?,
-            }),
-            "diagnostics" => Command::Diagnostics {
-                load_output_dirs: matches.contains("--load-output-dirs"),
-                with_proc_macro: matches.contains("--with-proc-macro"),
-                path: matches
-                    .opt_free_from_str()?
-                    .ok_or_else(|| format_err!("expected positional argument"))?,
-            },
-            "proc-macro" => Command::ProcMacro,
-            "ssr" => Command::Ssr {
-                rules: {
-                    let mut acc = Vec::new();
-                    while let Some(rule) = matches.opt_free_from_str()? {
-                        acc.push(rule);
-                    }
-                    acc
-                },
-            },
-            "search" => Command::StructuredSearch {
-                debug_snippet: matches.opt_value_from_str("--debug")?,
-                patterns: {
-                    let mut acc = Vec::new();
-                    while let Some(rule) = matches.opt_free_from_str()? {
-                        acc.push(rule);
-                    }
-                    acc
-                },
-            },
-            _ => {
-                eprintln!("{}", HELP);
-                return Ok(Args {
-                    verbosity,
-                    log_file: None,
-                    command: Command::Help,
-                    no_buffering,
-                    wait_dbg,
-                });
-            }
-        };
-        finish_args(matches)?;
-        Ok(Args { verbosity, log_file, command, no_buffering, wait_dbg })
-    }
-}
-
-fn finish_args(args: Arguments) -> Result<()> {
-    if !args.finish().is_empty() {
-        bail!("Unused arguments.");
-    }
-    Ok(())
-}
diff --git a/crates/rust-analyzer/src/bin/flags.rs b/crates/rust-analyzer/src/bin/flags.rs
new file mode 100644
index 000000000..244912d26
--- /dev/null
+++ b/crates/rust-analyzer/src/bin/flags.rs
@@ -0,0 +1,251 @@
+//! Grammar for the command-line arguments.
+#![allow(unreachable_pub)]
+use std::{env, path::PathBuf};
+
+use ide_ssr::{SsrPattern, SsrRule};
+use rust_analyzer::cli::{BenchWhat, Position, Verbosity};
+use vfs::AbsPathBuf;
+
+xflags::args_parser! {
+    /// LSP server for the Rust programming language.
+    cmd rust-analyzer {
+        /// Verbosity level, can be repeated multiple times.
+        repeated -v, --verbose
+        /// Verbosity level.
+        optional -q, --quiet
+
+        /// Log to the specified file instead of stderr.
+        optional --log-file path: PathBuf
+        /// Flush log records to the file immediately.
+        optional --no-log-buffering
+
+        /// Wait until a debugger is attached to (requires debug build).
+        optional --wait-dbg
+
+        default cmd lsp-server {
+            /// Print version.
+            optional --version
+            /// Print help.
+            optional -h, --help
+
+            /// Dump a LSP config JSON schema.
+            optional --print-config-schema
+        }
+
+        /// Parse stdin.
+        cmd parse {
+            /// Suppress printing.
+            optional --no-dump
+        }
+
+        /// Parse stdin and print the list of symbols.
+        cmd symbols {}
+
+        /// Highlight stdin as html.
+        cmd highlight {
+            /// Enable rainbow highlighting of identifiers.
+            optional --rainbow
+        }
+
+        /// Batch typecheck project and print summary statistics
+        cmd analysis-stats
+            /// Directory with Cargo.toml.
+            required path: PathBuf
+        {
+            /// Randomize order in which crates, modules, and items are processed.
+            optional --randomize
+            /// Run type inference in parallel.
+            optional --parallel
+            /// Collect memory usage statistics.
+            optional --memory-usage
+
+            /// Only analyze items matching this path.
+            optional -o, --only path: String
+            /// Also analyze all dependencies.
+            optional --with-deps
+
+            /// Load OUT_DIR values by running `cargo check` before analysis.
+            optional --load-output-dirs
+            /// Use proc-macro-srv for proc-macro expanding.
+            optional --with-proc-macro
+        }
+
+        /// Benchmark specific analysis operation
+        cmd analysis-bench
+            /// Directory with Cargo.toml.
+            required path: PathBuf
+        {
+            /// Collect memory usage statistics.
+            optional --memory-usage
+
+            /// Compute syntax highlighting for this file
+            optional --highlight path: PathBuf
+            /// Compute completions at file:line:column location.
+            optional --complete location: Position
+            /// Compute goto definition at file:line:column location.
+            optional --goto-def location: Position
+
+            /// Load OUT_DIR values by running `cargo check` before analysis.
+            optional --load-output-dirs
+            /// Use proc-macro-srv for proc-macro expanding.
+            optional --with-proc-macro
+        }
+
+        cmd diagnostics
+            /// Directory with Cargo.toml.
+            required path: PathBuf
+        {
+            /// Load OUT_DIR values by running `cargo check` before analysis.
+            optional --load-output-dirs
+            /// Use proc-macro-srv for proc-macro expanding.
+            optional --with-proc-macro
+        }
+
+        cmd ssr
+            /// A structured search replace rule (`$a.foo($b) ==> bar($a, $b)`)
+            repeated rule: SsrRule
+        {}
+
+        cmd search
+            /// A structured search replace pattern (`$a.foo($b)`)
+            repeated pattern: SsrPattern
+        {
+            /// Prints debug information for any nodes with source exactly equal to snippet.
+            optional --debug snippet: String
+        }
+
+        cmd proc-macro {}
+    }
+}
+
+// generated start
+// The following code is generated by `xflags` macro.
+// Run `env XFLAGS_DUMP= cargo build` to regenerate.
+#[derive(Debug)]
+pub struct RustAnalyzer {
+    pub verbose: u32,
+    pub quiet: bool,
+    pub log_file: Option<PathBuf>,
+    pub no_log_buffering: bool,
+    pub wait_dbg: bool,
+    pub subcommand: RustAnalyzerCmd,
+}
+
+#[derive(Debug)]
+pub enum RustAnalyzerCmd {
+    LspServer(LspServer),
+    Parse(Parse),
+    Symbols(Symbols),
+    Highlight(Highlight),
+    AnalysisStats(AnalysisStats),
+    AnalysisBench(AnalysisBench),
+    Diagnostics(Diagnostics),
+    Ssr(Ssr),
+    Search(Search),
+    ProcMacro(ProcMacro),
+}
+
+#[derive(Debug)]
+pub struct LspServer {
+    pub version: bool,
+    pub help: bool,
+    pub print_config_schema: bool,
+}
+
+#[derive(Debug)]
+pub struct Parse {
+    pub no_dump: bool,
+}
+
+#[derive(Debug)]
+pub struct Symbols {}
+
+#[derive(Debug)]
+pub struct Highlight {
+    pub rainbow: bool,
+}
+
+#[derive(Debug)]
+pub struct AnalysisStats {
+    pub path: PathBuf,
+
+    pub randomize: bool,
+    pub parallel: bool,
+    pub memory_usage: bool,
+    pub only: Option<String>,
+    pub with_deps: bool,
+    pub load_output_dirs: bool,
+    pub with_proc_macro: bool,
+}
+
+#[derive(Debug)]
+pub struct AnalysisBench {
+    pub path: PathBuf,
+
+    pub memory_usage: bool,
+    pub highlight: Option<PathBuf>,
+    pub complete: Option<Position>,
+    pub goto_def: Option<Position>,
+    pub load_output_dirs: bool,
+    pub with_proc_macro: bool,
+}
+
+#[derive(Debug)]
+pub struct Diagnostics {
+    pub path: PathBuf,
+
+    pub load_output_dirs: bool,
+    pub with_proc_macro: bool,
+}
+
+#[derive(Debug)]
+pub struct Ssr {
+    pub rule: Vec<SsrRule>,
+}
+
+#[derive(Debug)]
+pub struct Search {
+    pub pattern: Vec<SsrPattern>,
+
+    pub debug: Option<String>,
+}
+
+#[derive(Debug)]
+pub struct ProcMacro {}
+
+impl RustAnalyzer {
+    pub const HELP: &'static str = Self::_HELP;
+
+    pub fn from_env() -> xflags::Result<Self> {
+        let mut p = xflags::rt::Parser::new_from_env();
+        Self::_parse(&mut p)
+    }
+}
+// generated end
+
+impl RustAnalyzer {
+    pub(crate) fn verbosity(&self) -> Verbosity {
+        if self.quiet {
+            return Verbosity::Quiet;
+        }
+        match self.verbose {
+            0 => Verbosity::Normal,
+            1 => Verbosity::Verbose,
+            _ => Verbosity::Spammy,
+        }
+    }
+}
+
+impl AnalysisBench {
+    pub(crate) fn what(&self) -> BenchWhat {
+        match (&self.highlight, &self.complete, &self.goto_def) {
+            (Some(path), None, None) => {
+                let path = env::current_dir().unwrap().join(path);
+                BenchWhat::Highlight { path: AbsPathBuf::assert(path) }
+            }
+            (None, Some(position), None) => BenchWhat::Complete(position.clone()),
+            (None, None, Some(position)) => BenchWhat::GotoDef(position.clone()),
+            _ => panic!("exactly one of  `--highlight`, `--complete` or `--goto-def` must be set"),
+        }
+    }
+}
diff --git a/crates/rust-analyzer/src/bin/main.rs b/crates/rust-analyzer/src/bin/main.rs
index 89482b952..288847980 100644
--- a/crates/rust-analyzer/src/bin/main.rs
+++ b/crates/rust-analyzer/src/bin/main.rs
@@ -1,14 +1,20 @@
 //! Driver for rust-analyzer.
 //!
 //! Based on cli flags, either spawns an LSP server, or runs a batch analysis
-mod args;
+mod flags;
 mod logger;
 
-use std::{convert::TryFrom, env, fs, path::PathBuf, process};
+use std::{convert::TryFrom, env, fs, path::Path, process};
 
 use lsp_server::Connection;
 use project_model::ProjectManifest;
-use rust_analyzer::{cli, config::Config, from_json, lsp_ext::supports_utf8, Result};
+use rust_analyzer::{
+    cli::{self, AnalysisStatsCmd, BenchCmd},
+    config::Config,
+    from_json,
+    lsp_ext::supports_utf8,
+    Result,
+};
 use vfs::AbsPathBuf;
 
 #[cfg(all(feature = "mimalloc"))]
@@ -28,10 +34,10 @@ fn main() {
 }
 
 fn try_main() -> Result<()> {
-    let args = args::Args::parse()?;
+    let flags = flags::RustAnalyzer::from_env()?;
 
     #[cfg(debug_assertions)]
-    if args.wait_dbg || env::var("RA_WAIT_DBG").is_ok() {
+    if flags.wait_dbg || env::var("RA_WAIT_DBG").is_ok() {
         #[allow(unused_mut)]
         let mut d = 4;
         while d == 4 {
@@ -39,35 +45,62 @@ fn try_main() -> Result<()> {
         }
     }
 
-    setup_logging(args.log_file, args.no_buffering)?;
-    match args.command {
-        args::Command::RunServer => run_server()?,
-        args::Command::PrintConfigSchema => {
-            println!("{:#}", Config::json_schema());
+    setup_logging(flags.log_file.as_deref(), flags.no_log_buffering)?;
+    let verbosity = flags.verbosity();
+
+    match flags.subcommand {
+        flags::RustAnalyzerCmd::LspServer(cmd) => {
+            if cmd.print_config_schema {
+                println!("{:#}", Config::json_schema());
+                return Ok(());
+            }
+            if cmd.version {
+                println!("rust-analyzer {}", env!("REV"));
+                return Ok(());
+            }
+            if cmd.help {
+                println!("{}", flags::RustAnalyzer::HELP);
+                return Ok(());
+            }
+            run_server()?
         }
-        args::Command::ProcMacro => proc_macro_srv::cli::run()?,
-
-        args::Command::Parse { no_dump } => cli::parse(no_dump)?,
-        args::Command::Symbols => cli::symbols()?,
-        args::Command::Highlight { rainbow } => cli::highlight(rainbow)?,
-        args::Command::AnalysisStats(cmd) => cmd.run(args.verbosity)?,
-        args::Command::Bench(cmd) => cmd.run(args.verbosity)?,
-        args::Command::Diagnostics { path, load_output_dirs, with_proc_macro } => {
-            cli::diagnostics(path.as_ref(), load_output_dirs, with_proc_macro)?
+        flags::RustAnalyzerCmd::ProcMacro(_) => proc_macro_srv::cli::run()?,
+        flags::RustAnalyzerCmd::Parse(cmd) => cli::parse(cmd.no_dump)?,
+        flags::RustAnalyzerCmd::Symbols(_) => cli::symbols()?,
+        flags::RustAnalyzerCmd::Highlight(cmd) => cli::highlight(cmd.rainbow)?,
+        flags::RustAnalyzerCmd::AnalysisStats(cmd) => AnalysisStatsCmd {
+            randomize: cmd.randomize,
+            parallel: cmd.parallel,
+            memory_usage: cmd.memory_usage,
+            only: cmd.only,
+            with_deps: cmd.with_deps,
+            path: cmd.path,
+            load_output_dirs: cmd.load_output_dirs,
+            with_proc_macro: cmd.with_proc_macro,
         }
-        args::Command::Ssr { rules } => {
-            cli::apply_ssr_rules(rules)?;
+        .run(verbosity)?,
+        flags::RustAnalyzerCmd::AnalysisBench(cmd) => {
+            let what = cmd.what();
+            BenchCmd {
+                memory_usage: cmd.memory_usage,
+                path: cmd.path,
+                load_output_dirs: cmd.load_output_dirs,
+                with_proc_macro: cmd.with_proc_macro,
+                what,
+            }
+            .run(verbosity)?
         }
-        args::Command::StructuredSearch { patterns, debug_snippet } => {
-            cli::search_for_patterns(patterns, debug_snippet)?;
+
+        flags::RustAnalyzerCmd::Diagnostics(cmd) => {
+            cli::diagnostics(&cmd.path, cmd.load_output_dirs, cmd.with_proc_macro)?
         }
-        args::Command::Version => println!("rust-analyzer {}", env!("REV")),
-        args::Command::Help => {}
+        flags::RustAnalyzerCmd::Ssr(cmd) => cli::apply_ssr_rules(cmd.rule)?,
+        flags::RustAnalyzerCmd::Search(cmd) => cli::search_for_patterns(cmd.pattern, cmd.debug)?,
     }
     Ok(())
 }
 
-fn setup_logging(log_file: Option<PathBuf>, no_buffering: bool) -> Result<()> {
+fn setup_logging(log_file: Option<&Path>, no_buffering: bool) -> Result<()> {
     env::set_var("RUST_BACKTRACE", "short");
 
     let log_file = match log_file {
diff --git a/crates/rust-analyzer/src/cli/analysis_bench.rs b/crates/rust-analyzer/src/cli/analysis_bench.rs
index 8991f3bdb..3bd7e678d 100644
--- a/crates/rust-analyzer/src/cli/analysis_bench.rs
+++ b/crates/rust-analyzer/src/cli/analysis_bench.rs
@@ -35,6 +35,7 @@ pub enum BenchWhat {
     GotoDef(Position),
 }
 
+#[derive(Debug, Clone)]
 pub struct Position {
     pub path: AbsPathBuf,
     pub line: u32,
@@ -68,7 +69,7 @@ impl BenchCmd {
             load_out_dirs_from_check: self.load_output_dirs,
             with_proc_macro: self.with_proc_macro,
         };
-        let (mut host, vfs) =
+        let (mut host, vfs, _proc_macro) =
             load_workspace_at(&self.path, &cargo_config, &load_cargo_config, &|_| {})?;
         eprintln!("{:?}\n", start.elapsed());
 
diff --git a/crates/rust-analyzer/src/cli/analysis_stats.rs b/crates/rust-analyzer/src/cli/analysis_stats.rs
index 9072d8944..ad0759bda 100644
--- a/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -64,7 +64,7 @@ impl AnalysisStatsCmd {
             load_out_dirs_from_check: self.load_output_dirs,
             with_proc_macro: self.with_proc_macro,
         };
-        let (host, vfs) =
+        let (host, vfs, _proc_macro) =
             load_workspace_at(&self.path, &cargo_config, &load_cargo_config, &|_| {})?;
         let db = host.raw_database();
         eprintln!("{:<20} {}", "Database loaded:", db_load_sw.elapsed());
diff --git a/crates/rust-analyzer/src/cli/diagnostics.rs b/crates/rust-analyzer/src/cli/diagnostics.rs
index 876f6c44f..8b985716b 100644
--- a/crates/rust-analyzer/src/cli/diagnostics.rs
+++ b/crates/rust-analyzer/src/cli/diagnostics.rs
@@ -35,7 +35,8 @@ pub fn diagnostics(
 ) -> Result<()> {
     let cargo_config = Default::default();
     let load_cargo_config = LoadCargoConfig { load_out_dirs_from_check, with_proc_macro };
-    let (host, _vfs) = load_workspace_at(path, &cargo_config, &load_cargo_config, &|_| {})?;
+    let (host, _vfs, _proc_macro) =
+        load_workspace_at(path, &cargo_config, &load_cargo_config, &|_| {})?;
     let db = host.raw_database();
     let analysis = host.analysis();
 
diff --git a/crates/rust-analyzer/src/cli/load_cargo.rs b/crates/rust-analyzer/src/cli/load_cargo.rs
index 23442afac..310c36904 100644
--- a/crates/rust-analyzer/src/cli/load_cargo.rs
+++ b/crates/rust-analyzer/src/cli/load_cargo.rs
@@ -23,7 +23,7 @@ pub fn load_workspace_at(
     cargo_config: &CargoConfig,
     load_config: &LoadCargoConfig,
     progress: &dyn Fn(String),
-) -> Result<(AnalysisHost, vfs::Vfs)> {
+) -> Result<(AnalysisHost, vfs::Vfs, Option<ProcMacroClient>)> {
     let root = AbsPathBuf::assert(std::env::current_dir()?.join(root));
     let root = ProjectManifest::discover_single(&root)?;
     let workspace = ProjectWorkspace::load(root, cargo_config, progress)?;
@@ -35,7 +35,7 @@ pub fn load_workspace(
     ws: ProjectWorkspace,
     config: &LoadCargoConfig,
     progress: &dyn Fn(String),
-) -> Result<(AnalysisHost, vfs::Vfs)> {
+) -> Result<(AnalysisHost, vfs::Vfs, Option<ProcMacroClient>)> {
     let (sender, receiver) = unbounded();
     let mut vfs = vfs::Vfs::default();
     let mut loader = {
@@ -80,7 +80,7 @@ pub fn load_workspace(
     log::debug!("crate graph: {:?}", crate_graph);
     let host =
         load_crate_graph(crate_graph, project_folders.source_root_config, &mut vfs, &receiver);
-    Ok((host, vfs))
+    Ok((host, vfs, proc_macro_client))
 }
 
 fn load_crate_graph(
@@ -138,7 +138,8 @@ mod tests {
         let cargo_config = Default::default();
         let load_cargo_config =
             LoadCargoConfig { load_out_dirs_from_check: false, with_proc_macro: false };
-        let (host, _vfs) = load_workspace_at(path, &cargo_config, &load_cargo_config, &|_| {})?;
+        let (host, _vfs, _proc_macro) =
+            load_workspace_at(path, &cargo_config, &load_cargo_config, &|_| {})?;
 
         let n_crates = Crate::all(host.raw_database()).len();
         // RA has quite a few crates, but the exact count doesn't matter
diff --git a/crates/rust-analyzer/src/cli/ssr.rs b/crates/rust-analyzer/src/cli/ssr.rs
index 71a8f8fb9..79f426fff 100644
--- a/crates/rust-analyzer/src/cli/ssr.rs
+++ b/crates/rust-analyzer/src/cli/ssr.rs
@@ -11,7 +11,7 @@ pub fn apply_ssr_rules(rules: Vec<SsrRule>) -> Result<()> {
     let cargo_config = Default::default();
     let load_cargo_config =
         LoadCargoConfig { load_out_dirs_from_check: true, with_proc_macro: true };
-    let (host, vfs) =
+    let (host, vfs, _proc_macro) =
         load_workspace_at(&std::env::current_dir()?, &cargo_config, &load_cargo_config, &|_| {})?;
     let db = host.raw_database();
     let mut match_finder = MatchFinder::at_first_file(db)?;
@@ -38,7 +38,7 @@ pub fn search_for_patterns(patterns: Vec<SsrPattern>, debug_snippet: Option<Stri
     let cargo_config = Default::default();
     let load_cargo_config =
         LoadCargoConfig { load_out_dirs_from_check: true, with_proc_macro: true };
-    let (host, _vfs) =
+    let (host, _vfs, _proc_macro) =
         load_workspace_at(&std::env::current_dir()?, &cargo_config, &load_cargo_config, &|_| {})?;
     let db = host.raw_database();
     let mut match_finder = MatchFinder::at_first_file(db)?;
diff --git a/crates/syntax/src/ast/edit.rs b/crates/syntax/src/ast/edit.rs
index 824ebf41c..0b3b76d4a 100644
--- a/crates/syntax/src/ast/edit.rs
+++ b/crates/syntax/src/ast/edit.rs
@@ -595,11 +595,14 @@ impl ops::Add<u8> for IndentLevel {
 
 impl IndentLevel {
     pub fn from_node(node: &SyntaxNode) -> IndentLevel {
-        let first_token = match node.first_token() {
-            Some(it) => it,
+        match node.first_token() {
+            Some(it) => Self::from_token(&it),
             None => return IndentLevel(0),
-        };
-        for ws in prev_tokens(first_token).filter_map(ast::Whitespace::cast) {
+        }
+    }
+
+    pub fn from_token(token: &SyntaxToken) -> IndentLevel {
+        for ws in prev_tokens(token.clone()).filter_map(ast::Whitespace::cast) {
             let text = ws.syntax().text();
             if let Some(pos) = text.rfind('\n') {
                 let level = text[pos + 1..].chars().count() / 4;
diff --git a/crates/syntax/src/ast/token_ext.rs b/crates/syntax/src/ast/token_ext.rs
index 044e3e5e8..977eb8181 100644
--- a/crates/syntax/src/ast/token_ext.rs
+++ b/crates/syntax/src/ast/token_ext.rs
@@ -85,8 +85,9 @@ pub enum CommentPlacement {
 }
 
 impl CommentKind {
-    const BY_PREFIX: [(&'static str, CommentKind); 8] = [
+    const BY_PREFIX: [(&'static str, CommentKind); 9] = [
         ("/**/", CommentKind { shape: CommentShape::Block, doc: None }),
+        ("/***", CommentKind { shape: CommentShape::Block, doc: None }),
         ("////", CommentKind { shape: CommentShape::Line, doc: None }),
         ("///", CommentKind { shape: CommentShape::Line, doc: Some(CommentPlacement::Outer) }),
         ("//!", CommentKind { shape: CommentShape::Line, doc: Some(CommentPlacement::Inner) }),