rust-analyzer

diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index 1070a26c26..645b10f853 100644
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs

@@ -10,7 +10,7 @@ use hir_def::{

resolver::{self, HasResolver, Resolver, TypeNs},

AsMacroCall, FunctionId, TraitId, VariantId,

};

-use hir_expand::{name::AsName, ExpansionInfo, MacroCallId, MacroCallLoc};

+use hir_expand::{name::AsName, ExpansionInfo, MacroCallId};

use hir_ty::{associated_type_shorthand_candidates, Interner};

use itertools::Itertools;

use rustc_hash::{FxHashMap, FxHashSet};

@@ -160,7 +160,7 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {

self.imp.expand_attr_macro(item)

}

- pub fn resolve_derive_macro(&self, derive: &ast::Attr) -> Option<Vec<MacroDef>> {

+ pub fn resolve_derive_macro(&self, derive: &ast::Attr) -> Option<Vec<Option<MacroDef>>> {

self.imp.resolve_derive_macro(derive)

}

@@ -447,14 +447,11 @@ impl<'db> SemanticsImpl<'db> {

Some(node)

}

- fn resolve_derive_macro(&self, attr: &ast::Attr) -> Option<Vec<MacroDef>> {

+ fn resolve_derive_macro(&self, attr: &ast::Attr) -> Option<Vec<Option<MacroDef>>> {

let res = self

.derive_macro_calls(attr)?

- .iter()

- .map(|&call| {

- let loc: MacroCallLoc = self.db.lookup_intern_macro_call(call);

- MacroDef { id: loc.def }

- })

+ .into_iter()

+ .map(|call| Some(MacroDef { id: self.db.lookup_intern_macro_call(call?).def }))

.collect();

Some(res)

}

@@ -462,9 +459,9 @@ impl<'db> SemanticsImpl<'db> {

fn expand_derive_macro(&self, attr: &ast::Attr) -> Option<Vec<SyntaxNode>> {

let res: Vec<_> = self

.derive_macro_calls(attr)?

- .iter()

- .map(|call| call.as_file())

- .flat_map(|file_id| {

+ .into_iter()

+ .flat_map(|call| {

+ let file_id = call?.as_file();

let node = self.db.parse_or_expand(file_id)?;

self.cache(node.clone(), file_id);

Some(node)

@@ -473,7 +470,7 @@ impl<'db> SemanticsImpl<'db> {

Some(res)

}

- fn derive_macro_calls(&self, attr: &ast::Attr) -> Option<Vec<MacroCallId>> {

+ fn derive_macro_calls(&self, attr: &ast::Attr) -> Option<Vec<Option<MacroCallId>>> {

let item = attr.syntax().parent().and_then(ast::Item::cast)?;

let file_id = self.find_file(item.syntax()).file_id;

let item = InFile::new(file_id, &item);

diff --git a/crates/hir/src/semantics/source_to_def.rs b/crates/hir/src/semantics/source_to_def.rs
index dd83f1c86e..495c84e65f 100644
--- a/crates/hir/src/semantics/source_to_def.rs
+++ b/crates/hir/src/semantics/source_to_def.rs

@@ -248,7 +248,7 @@ impl SourceToDefCtx<'_, '_> {

&mut self,

item: InFile<&ast::Item>,

src: InFile<ast::Attr>,

- ) -> Option<&[MacroCallId]> {

+ ) -> Option<&[Option<MacroCallId>]> {

let map = self.dyn_map(item)?;

map[keys::DERIVE_MACRO].get(&src).map(AsRef::as_ref)

}

diff --git a/crates/hir_def/src/child_by_source.rs b/crates/hir_def/src/child_by_source.rs
index 1baf74c512..5ab236aa3d 100644
--- a/crates/hir_def/src/child_by_source.rs
+++ b/crates/hir_def/src/child_by_source.rs

@@ -6,7 +6,6 @@

use either::Either;

use hir_expand::HirFileId;

-use itertools::Itertools;

use syntax::ast::HasAttrs;

use crate::{

@@ -123,8 +122,7 @@ impl ChildBySource for ItemScope {

});

self.derive_macro_invocs().for_each(|(ast_id, calls)| {

let item = ast_id.to_node(db.upcast());

- let grouped = calls.iter().copied().into_group_map();

- for (attr_id, calls) in grouped {

+ for (attr_id, calls) in calls {

if let Some(attr) = item.attrs().nth(attr_id.ast_index as usize) {

res[keys::DERIVE_MACRO].insert(ast_id.with_value(attr), calls.into());

}

diff --git a/crates/hir_def/src/item_scope.rs b/crates/hir_def/src/item_scope.rs
index 37599371f6..25369fdb26 100644
--- a/crates/hir_def/src/item_scope.rs
+++ b/crates/hir_def/src/item_scope.rs

@@ -8,7 +8,7 @@ use hir_expand::{name::Name, AstId, MacroCallId, MacroDefKind};

use once_cell::sync::Lazy;

use profile::Count;

use rustc_hash::{FxHashMap, FxHashSet};

-use smallvec::SmallVec;

+use smallvec::{smallvec, SmallVec};

use stdx::format_to;

use syntax::ast;

@@ -64,7 +64,10 @@ pub struct ItemScope {

// be all resolved to the last one defined if shadowing happens.

legacy_macros: FxHashMap<Name, MacroDefId>,

attr_macros: FxHashMap<AstId<ast::Item>, MacroCallId>,

- derive_macros: FxHashMap<AstId<ast::Item>, SmallVec<[(AttrId, MacroCallId); 1]>>,

+ /// The derive macro invocations in this scope, keyed by the owner item over the actual derive attributes

+ /// paired with the derive macro invocations for the specific attribute.

+ derive_macros:

+ FxHashMap<AstId<ast::Item>, SmallVec<[(AttrId, SmallVec<[Option<MacroCallId>; 1]>); 1]>>,

}

pub(crate) static BUILTIN_SCOPE: Lazy<FxHashMap<Name, PerNs>> = Lazy::new(|| {

@@ -199,19 +202,40 @@ impl ItemScope {

self.attr_macros.iter().map(|(k, v)| (*k, *v))

}

- pub(crate) fn add_derive_macro_invoc(

+ pub(crate) fn set_derive_macro_invoc(

&mut self,

item: AstId<ast::Item>,

call: MacroCallId,

attr_id: AttrId,

+ idx: usize,

) {

- self.derive_macros.entry(item).or_default().push((attr_id, call));

+ if let Some(derives) = self.derive_macros.get_mut(&item) {

+ if let Some((_, invocs)) = derives.iter_mut().find(|&&mut (id, _)| id == attr_id) {

+ invocs[idx] = Some(call);

+ }

+ /// We are required to set this up front as derive invocation recording happens out of order

+ /// due to the fixed pointer iteration loop being able to record some derives later than others

+ /// independent of their indices.

+ pub(crate) fn init_derive_attribute(

+ &mut self,

+ item: AstId<ast::Item>,

+ attr_id: AttrId,

+ len: usize,

+ ) {

+ self.derive_macros.entry(item).or_default().push((attr_id, smallvec![None; len]));

}

pub(crate) fn derive_macro_invocs(

&self,

- ) -> impl Iterator<Item = (AstId<ast::Item>, &[(AttrId, MacroCallId)])> + '_ {

- self.derive_macros.iter().map(|(k, v)| (*k, v.as_ref()))

+ ) -> impl Iterator<

+ Item = (AstId<ast::Item>, impl Iterator<Item = (AttrId, &[Option<MacroCallId>])>),

+ > + '_ {

+ self.derive_macros

+ .iter()

+ .map(|(k, v)| (*k, v.iter().map(|(attr_id, invocs)| (*attr_id, &**invocs))))

}

pub(crate) fn unnamed_trait_vis(&self, tr: TraitId) -> Option<Visibility> {

diff --git a/crates/hir_def/src/keys.rs b/crates/hir_def/src/keys.rs
index 07c4d083d6..6a7dc13ff1 100644
--- a/crates/hir_def/src/keys.rs
+++ b/crates/hir_def/src/keys.rs

@@ -33,7 +33,7 @@ pub const CONST_PARAM: Key<ast::ConstParam, ConstParamId> = Key::new();

pub const MACRO: Key<ast::Macro, MacroDefId> = Key::new();

pub const ATTR_MACRO: Key<ast::Item, MacroCallId> = Key::new();

-pub const DERIVE_MACRO: Key<ast::Attr, Box<[MacroCallId]>> = Key::new();

+pub const DERIVE_MACRO: Key<ast::Attr, Box<[Option<MacroCallId>]>> = Key::new();

/// XXX: AST Nodes and SyntaxNodes have identity equality semantics: nodes are

/// equal if they point to exactly the same object.

diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 8c0ba3c056..ca8afe8cbf 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs

@@ -219,7 +219,7 @@ struct MacroDirective {

#[derive(Clone, Debug, Eq, PartialEq)]

enum MacroDirectiveKind {

FnLike { ast_id: AstIdWithPath<ast::MacroCall>, expand_to: ExpandTo },

- Derive { ast_id: AstIdWithPath<ast::Item>, derive_attr: AttrId },

+ Derive { ast_id: AstIdWithPath<ast::Item>, derive_attr: AttrId, derive_pos: usize },

Attr { ast_id: AstIdWithPath<ast::Item>, attr: Attr, mod_item: ModItem, tree: TreeId },

}

@@ -1064,7 +1064,7 @@ impl DefCollector<'_> {

return false;

}

- MacroDirectiveKind::Derive { ast_id, derive_attr } => {

+ MacroDirectiveKind::Derive { ast_id, derive_attr, derive_pos } => {

let call_id = derive_macro_as_call_id(

ast_id,

*derive_attr,

@@ -1073,10 +1073,11 @@ impl DefCollector<'_> {

&resolver,

);

if let Ok(call_id) = call_id {

- self.def_map.modules[directive.module_id].scope.add_derive_macro_invoc(

+ self.def_map.modules[directive.module_id].scope.set_derive_macro_invoc(

ast_id.ast_id,

call_id,

*derive_attr,

+ *derive_pos,

);

resolved.push((

@@ -1146,7 +1147,8 @@ impl DefCollector<'_> {

match attr.parse_derive() {

Some(derive_macros) => {

- for path in derive_macros {

+ let mut len = 0;

+ for (idx, path) in derive_macros.enumerate() {

let ast_id = AstIdWithPath::new(file_id, ast_id.value, path);

self.unresolved_macros.push(MacroDirective {

module_id: directive.module_id,

@@ -1154,10 +1156,16 @@ impl DefCollector<'_> {

kind: MacroDirectiveKind::Derive {

ast_id,

derive_attr: attr.id,

+ derive_pos: idx,

container: directive.container,

});

+ len = idx;

}

+ self.def_map.modules[directive.module_id]

+ .scope

+ .init_derive_attribute(ast_id, attr.id, len + 1);

}

None => {

let diag = DefDiagnostic::malformed_derive(

diff --git a/crates/ide_completion/src/completions/attribute/derive.rs b/crates/ide_completion/src/completions/attribute/derive.rs
index 8aaade350f..5b22408a2c 100644
--- a/crates/ide_completion/src/completions/attribute/derive.rs
+++ b/crates/ide_completion/src/completions/attribute/derive.rs

@@ -16,7 +16,7 @@ use crate::{

pub(super) fn complete_derive(acc: &mut Completions, ctx: &CompletionContext, attr: &ast::Attr) {

let core = ctx.famous_defs().core();

let existing_derives: FxHashSet<_> =

- ctx.sema.resolve_derive_macro(attr).into_iter().flatten().collect();

+ ctx.sema.resolve_derive_macro(attr).into_iter().flatten().flatten().collect();

for (name, mac) in get_derives_in_scope(ctx) {

if existing_derives.contains(&mac) {