10 files changed, 239 insertions, 32 deletions

diff --git a/crates/ra_hir_def/src/attr.rs b/crates/ra_hir_def/src/attr.rs
index 714a66b02..5a86af8ba 100644
--- a/crates/ra_hir_def/src/attr.rs
+++ b/crates/ra_hir_def/src/attr.rs
@@ -13,7 +13,8 @@ use ra_syntax::{
 use tt::Subtree;
 
 use crate::{
-    db::DefDatabase, path::ModPath, src::HasChildSource, src::HasSource, AdtId, AttrDefId, Lookup,
+    db::DefDatabase, nameres::ModuleSource, path::ModPath, src::HasChildSource, src::HasSource,
+    AdtId, AttrDefId, Lookup,
 };
 
 #[derive(Default, Debug, Clone, PartialEq, Eq)]
@@ -37,11 +38,19 @@ impl Attrs {
         match def {
             AttrDefId::ModuleId(module) => {
                 let def_map = db.crate_def_map(module.krate);
-                let src = match def_map[module.local_id].declaration_source(db) {
-                    Some(it) => it,
-                    None => return Attrs::default(),
-                };
-                Attrs::from_attrs_owner(db, src.as_ref().map(|it| it as &dyn AttrsOwner))
+                let mod_data = &def_map[module.local_id];
+                match mod_data.declaration_source(db) {
+                    Some(it) => {
+                        Attrs::from_attrs_owner(db, it.as_ref().map(|it| it as &dyn AttrsOwner))
+                    }
+                    None => Attrs::from_attrs_owner(
+                        db,
+                        mod_data.definition_source(db).as_ref().map(|src| match src {
+                            ModuleSource::SourceFile(file) => file as &dyn AttrsOwner,
+                            ModuleSource::Module(module) => module as &dyn AttrsOwner,
+                        }),
+                    ),
+                }
             }
             AttrDefId::FieldId(it) => {
                 let src = it.parent.child_source(db);
@@ -106,7 +115,9 @@ pub struct Attr {
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum AttrInput {
+    /// `#[attr = "string"]`
     Literal(SmolStr),
+    /// `#[attr(subtree)]`
     TokenTree(Subtree),
 }
 
diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
index 0caedd8d8..571603854 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -141,6 +141,10 @@ impl ExprCollector<'_> {
 
     fn collect_expr(&mut self, expr: ast::Expr) -> ExprId {
         let syntax_ptr = AstPtr::new(&expr);
+        let attrs = self.expander.parse_attrs(&expr);
+        if !self.expander.is_cfg_enabled(&attrs) {
+            return self.missing_expr();
+        }
         match expr {
             ast::Expr::IfExpr(e) => {
                 let then_branch = self.collect_block_opt(e.then_branch());
diff --git a/crates/ra_hir_def/src/find_path.rs b/crates/ra_hir_def/src/find_path.rs
index 81eff5bfe..70dcb03e6 100644
--- a/crates/ra_hir_def/src/find_path.rs
+++ b/crates/ra_hir_def/src/find_path.rs
@@ -19,7 +19,7 @@ impl ModPath {
 
     // When std library is present, paths starting with `std::`
     // should be preferred over paths starting with `core::` and `alloc::`
-    fn should_start_with_std(&self) -> bool {
+    fn can_start_with_std(&self) -> bool {
         self.segments
             .first()
             .filter(|&first_segment| {
@@ -132,6 +132,9 @@ fn find_path_inner(
     }
 
     // - otherwise, look for modules containing (reexporting) it and import it from one of those
+    let crate_root = ModuleId { local_id: def_map.root, krate: from.krate };
+    let crate_attrs = db.attrs(crate_root.into());
+    let prefer_no_std = crate_attrs.by_key("no_std").exists();
     let importable_locations = find_importable_locations(db, item, from);
     let mut best_path = None;
     let mut best_path_len = max_len;
@@ -147,21 +150,32 @@ fn find_path_inner(
         };
         path.segments.push(name);
 
-        let new_path =
-            if let Some(best_path) = best_path { select_best_path(best_path, path) } else { path };
+        let new_path = if let Some(best_path) = best_path {
+            select_best_path(best_path, path, prefer_no_std)
+        } else {
+            path
+        };
         best_path_len = new_path.len();
         best_path = Some(new_path);
     }
     best_path
 }
 
-fn select_best_path(old_path: ModPath, new_path: ModPath) -> ModPath {
-    if old_path.starts_with_std() && new_path.should_start_with_std() {
+fn select_best_path(old_path: ModPath, new_path: ModPath, prefer_no_std: bool) -> ModPath {
+    if old_path.starts_with_std() && new_path.can_start_with_std() {
         tested_by!(prefer_std_paths);
-        old_path
-    } else if new_path.starts_with_std() && old_path.should_start_with_std() {
+        if prefer_no_std {
+            new_path
+        } else {
+            old_path
+        }
+    } else if new_path.starts_with_std() && old_path.can_start_with_std() {
         tested_by!(prefer_std_paths);
-        new_path
+        if prefer_no_std {
+            old_path
+        } else {
+            new_path
+        }
     } else if new_path.len() < old_path.len() {
         new_path
     } else {
@@ -513,6 +527,54 @@ mod tests {
     }
 
     #[test]
+    fn prefer_alloc_paths_over_std() {
+        covers!(prefer_std_paths);
+        let code = r#"
+        //- /main.rs crate:main deps:alloc,std
+        #![no_std]
+
+        <|>
+
+        //- /std.rs crate:std deps:alloc
+
+        pub mod sync {
+            pub use alloc::sync::Arc;
+        }
+
+        //- /zzz.rs crate:alloc
+
+        pub mod sync {
+            pub struct Arc;
+        }
+        "#;
+        check_found_path(code, "alloc::sync::Arc");
+    }
+
+    #[test]
+    fn prefer_core_paths_over_std() {
+        covers!(prefer_std_paths);
+        let code = r#"
+        //- /main.rs crate:main deps:core,std
+        #![no_std]
+
+        <|>
+
+        //- /std.rs crate:std deps:core
+
+        pub mod fmt {
+            pub use core::fmt::Error;
+        }
+
+        //- /zzz.rs crate:core
+
+        pub mod fmt {
+            pub struct Error;
+        }
+        "#;
+        check_found_path(code, "core::fmt::Error");
+    }
+
+    #[test]
     fn prefer_shorter_paths_if_not_alloc() {
         let code = r#"
         //- /main.rs crate:main deps:megaalloc,std
diff --git a/crates/ra_hir_ty/src/tests.rs b/crates/ra_hir_ty/src/tests.rs
index b6a96bb5c..588d81282 100644
--- a/crates/ra_hir_ty/src/tests.rs
+++ b/crates/ra_hir_ty/src/tests.rs
@@ -391,6 +391,38 @@ fn no_such_field_with_feature_flag_diagnostics_on_struct_lit() {
 }
 
 #[test]
+fn no_such_field_with_feature_flag_diagnostics_on_block_expr() {
+    let diagnostics = TestDB::with_files(
+        r#"
+        //- /lib.rs crate:foo cfg:feature=foo
+        struct S {
+            #[cfg(feature = "foo")]
+            foo: u32,
+            #[cfg(not(feature = "foo"))]
+            bar: u32,
+        }
+
+        impl S {
+            fn new(bar: u32) -> Self {
+                #[cfg(feature = "foo")]
+                {
+                Self { foo: bar }
+                }
+                #[cfg(not(feature = "foo"))]
+                {
+                Self { bar }
+                }
+            }
+        }
+        "#,
+    )
+    .diagnostics()
+    .0;
+
+    assert_snapshot!(diagnostics, @r###""###);
+}
+
+#[test]
 fn no_such_field_with_feature_flag_diagnostics_on_struct_fields() {
     let diagnostics = TestDB::with_files(
         r#"
diff --git a/crates/ra_mbe/src/lib.rs b/crates/ra_mbe/src/lib.rs
index 535b7daa0..1a020398e 100644
--- a/crates/ra_mbe/src/lib.rs
+++ b/crates/ra_mbe/src/lib.rs
@@ -19,6 +19,7 @@ use crate::{
 #[derive(Debug, PartialEq, Eq)]
 pub enum ParseError {
     Expected(String),
+    RepetitionEmtpyTokenTree,
 }
 
 #[derive(Debug, PartialEq, Eq)]
@@ -194,20 +195,46 @@ impl Rule {
     }
 }
 
+fn to_parse_error(e: ExpandError) -> ParseError {
+    let msg = match e {
+        ExpandError::InvalidRepeat => "invalid repeat".to_string(),
+        _ => "invalid macro definition".to_string(),
+    };
+    ParseError::Expected(msg)
+}
+
 fn validate(pattern: &tt::Subtree) -> Result<(), ParseError> {
     for op in parse_pattern(pattern) {
-        let op = match op {
-            Ok(it) => it,
-            Err(e) => {
-                let msg = match e {
-                    ExpandError::InvalidRepeat => "invalid repeat".to_string(),
-                    _ => "invalid macro definition".to_string(),
-                };
-                return Err(ParseError::Expected(msg));
-            }
-        };
+        let op = op.map_err(to_parse_error)?;
+
         match op {
-            Op::TokenTree(tt::TokenTree::Subtree(subtree)) | Op::Repeat { subtree, .. } => {
+            Op::TokenTree(tt::TokenTree::Subtree(subtree)) => validate(subtree)?,
+            Op::Repeat { subtree, separator, .. } => {
+                // Checks that no repetition which could match an empty token
+                // https://github.com/rust-lang/rust/blob/a58b1ed44f5e06976de2bdc4d7dc81c36a96934f/src/librustc_expand/mbe/macro_rules.rs#L558
+
+                if separator.is_none() {
+                    if parse_pattern(subtree).all(|child_op| {
+                        match child_op.map_err(to_parse_error) {
+                            Ok(Op::Var { kind, .. }) => {
+                                // vis is optional
+                                if kind.map_or(false, |it| it == "vis") {
+                                    return true;
+                                }
+                            }
+                            Ok(Op::Repeat { kind, .. }) => {
+                                return matches!(
+                                    kind,
+                                    parser::RepeatKind::ZeroOrMore | parser::RepeatKind::ZeroOrOne
+                                )
+                            }
+                            _ => {}
+                        }
+                        false
+                    }) {
+                        return Err(ParseError::RepetitionEmtpyTokenTree);
+                    }
+                }
                 validate(subtree)?
             }
             _ => (),
@@ -216,6 +243,7 @@ fn validate(pattern: &tt::Subtree) -> Result<(), ParseError> {
     Ok(())
 }
 
+#[derive(Debug)]
 pub struct ExpandResult<T>(pub T, pub Option<ExpandError>);
 
 impl<T> ExpandResult<T> {
diff --git a/crates/ra_mbe/src/tests.rs b/crates/ra_mbe/src/tests.rs
index 7ceec7752..0d924ce58 100644
--- a/crates/ra_mbe/src/tests.rs
+++ b/crates/ra_mbe/src/tests.rs
@@ -1657,7 +1657,7 @@ impl MacroFixture {
     }
 }
 
-pub(crate) fn parse_macro(ra_fixture: &str) -> MacroFixture {
+fn parse_macro_to_tt(ra_fixture: &str) -> tt::Subtree {
     let source_file = ast::SourceFile::parse(ra_fixture).ok().unwrap();
     let macro_definition =
         source_file.syntax().descendants().find_map(ast::MacroCall::cast).unwrap();
@@ -1671,10 +1671,24 @@ pub(crate) fn parse_macro(ra_fixture: &str) -> MacroFixture {
     .0;
     assert_eq!(definition_tt, parsed);
 
+    definition_tt
+}
+
+pub(crate) fn parse_macro(ra_fixture: &str) -> MacroFixture {
+    let definition_tt = parse_macro_to_tt(ra_fixture);
     let rules = MacroRules::parse(&definition_tt).unwrap();
     MacroFixture { rules }
 }
 
+pub(crate) fn parse_macro_error(ra_fixture: &str) -> ParseError {
+    let definition_tt = parse_macro_to_tt(ra_fixture);
+
+    match MacroRules::parse(&definition_tt) {
+        Ok(_) => panic!("Expect error"),
+        Err(err) => err,
+    }
+}
+
 pub(crate) fn parse_to_token_tree_by_syntax(ra_fixture: &str) -> tt::Subtree {
     let source_file = ast::SourceFile::parse(ra_fixture).ok().unwrap();
     let tt = syntax_node_to_token_tree(source_file.syntax()).unwrap().0;
@@ -1840,6 +1854,27 @@ fn test_no_space_after_semi_colon() {
     );
 }
 
+// https://github.com/rust-lang/rust/blob/master/src/test/ui/issues/issue-57597.rs
+#[test]
+fn test_rustc_issue_57597() {
+    fn test_error(fixture: &str) {
+        assert_eq!(parse_macro_error(fixture), ParseError::RepetitionEmtpyTokenTree);
+    }
+
+    test_error("macro_rules! foo { ($($($i:ident)?)+) => {}; }");
+    test_error("macro_rules! foo { ($($($i:ident)?)*) => {}; }");
+    test_error("macro_rules! foo { ($($($i:ident)?)?) => {}; }");
+    test_error("macro_rules! foo { ($($($($i:ident)?)?)?) => {}; }");
+    test_error("macro_rules! foo { ($($($($i:ident)*)?)?) => {}; }");
+    test_error("macro_rules! foo { ($($($($i:ident)?)*)?) => {}; }");
+    test_error("macro_rules! foo { ($($($($i:ident)?)?)*) => {}; }");
+    test_error("macro_rules! foo { ($($($($i:ident)*)*)?) => {}; }");
+    test_error("macro_rules! foo { ($($($($i:ident)?)*)*) => {}; }");
+    test_error("macro_rules! foo { ($($($($i:ident)?)*)+) => {}; }");
+    test_error("macro_rules! foo { ($($($($i:ident)+)?)*) => {}; }");
+    test_error("macro_rules! foo { ($($($($i:ident)+)*)?) => {}; }");
+}
+
 #[test]
 fn test_expand_bad_literal() {
     parse_macro(
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 715eddadb..74a63e32a 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -69,6 +69,7 @@ pub enum RustfmtConfig {
 pub struct ClientCapsConfig {
     pub location_link: bool,
     pub line_folding_only: bool,
+    pub hierarchical_symbols: bool,
 }
 
 impl Default for Config {
@@ -215,6 +216,11 @@ impl Config {
         if let Some(value) = caps.folding_range.as_ref().and_then(|it| it.line_folding_only) {
             self.client_caps.line_folding_only = value
         }
+        if let Some(value) =
+            caps.document_symbol.as_ref().and_then(|it| it.hierarchical_document_symbol_support)
+        {
+            self.client_caps.hierarchical_symbols = value
+        }
         self.completion.allow_snippets(false);
         if let Some(completion) = &caps.completion {
             if let Some(completion_item) = &completion.completion_item {
diff --git a/crates/rust-analyzer/src/main_loop/handlers.rs b/crates/rust-analyzer/src/main_loop/handlers.rs
index c2c1a23cd..e87e8db5d 100644
--- a/crates/rust-analyzer/src/main_loop/handlers.rs
+++ b/crates/rust-analyzer/src/main_loop/handlers.rs
@@ -16,7 +16,7 @@ use lsp_types::{
     Hover, HoverContents, Location, MarkupContent, MarkupKind, Position, PrepareRenameResponse,
     Range, RenameParams, SemanticTokensParams, SemanticTokensRangeParams,
     SemanticTokensRangeResult, SemanticTokensResult, SymbolInformation, TextDocumentIdentifier,
-    TextEdit, WorkspaceEdit,
+    TextEdit, Url, WorkspaceEdit,
 };
 use ra_ide::{
     Assist, AssistId, FileId, FilePosition, FileRange, Query, RangeInfo, Runnable, RunnableKind,
@@ -219,6 +219,7 @@ pub fn handle_document_symbol(
     let _p = profile("handle_document_symbol");
     let file_id = params.text_document.try_conv_with(&world)?;
     let line_index = world.analysis().file_line_index(file_id)?;
+    let url = file_id.try_conv_with(&world)?;
 
     let mut parents: Vec<(DocumentSymbol, Option<usize>)> = Vec::new();
 
@@ -234,10 +235,10 @@ pub fn handle_document_symbol(
         };
         parents.push((doc_symbol, symbol.parent));
     }
-    let mut res = Vec::new();
+    let mut document_symbols = Vec::new();
     while let Some((node, parent)) = parents.pop() {
         match parent {
-            None => res.push(node),
+            None => document_symbols.push(node),
             Some(i) => {
                 let children = &mut parents[i].0.children;
                 if children.is_none() {
@@ -248,7 +249,35 @@ pub fn handle_document_symbol(
         }
     }
 
-    Ok(Some(res.into()))
+    if world.config.client_caps.hierarchical_symbols {
+        Ok(Some(document_symbols.into()))
+    } else {
+        let mut symbol_information = Vec::<SymbolInformation>::new();
+        for symbol in document_symbols {
+            flatten_document_symbol(&symbol, None, &url, &mut symbol_information);
+        }
+
+        Ok(Some(symbol_information.into()))
+    }
+}
+
+fn flatten_document_symbol(
+    symbol: &DocumentSymbol,
+    container_name: Option<String>,
+    url: &Url,
+    res: &mut Vec<SymbolInformation>,
+) {
+    res.push(SymbolInformation {
+        name: symbol.name.clone(),
+        kind: symbol.kind,
+        deprecated: symbol.deprecated,
+        location: Location::new(url.clone(), symbol.range),
+        container_name: container_name,
+    });
+
+    for child in symbol.children.iter().flatten() {
+        flatten_document_symbol(child, Some(symbol.name.clone()), url, res);
+    }
 }
 
 pub fn handle_workspace_symbol(
diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 0ad4b63ae..97e794091 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -4,7 +4,7 @@ import * as vscode from 'vscode';
 import { CallHierarchyFeature } from 'vscode-languageclient/lib/callHierarchy.proposed';
 import { SemanticTokensFeature, DocumentSemanticsTokensSignature } from 'vscode-languageclient/lib/semanticTokens.proposed';
 
-export async function createClient(serverPath: string, cwd: string): Promise<lc.LanguageClient> {
+export function createClient(serverPath: string, cwd: string): lc.LanguageClient {
     // '.' Is the fallback if no folder is open
     // TODO?: Workspace folders support Uri's (eg: file://test.txt).
     // It might be a good idea to test if the uri points to a file.
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index f7ed62d03..41df11991 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -21,7 +21,7 @@ export class Ctx {
         serverPath: string,
         cwd: string,
     ): Promise<Ctx> {
-        const client = await createClient(serverPath, cwd);
+        const client = createClient(serverPath, cwd);
         const res = new Ctx(config, extCtx, client, serverPath);
         res.pushCleanup(client.start());
         await client.onReady();