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

ast_id.with_value(SyntaxNodePtr::from(AstPtr::new(&node)))

}

// FIXME: point to the attribute instead, this creates very large diagnostics

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

ast_id.with_value(SyntaxNodePtr::from(AstPtr::new(&node)))

use smallvec::{smallvec, SmallVec};

use syntax::{

algo::skip_trivia_token,

match_ast, AstNode, AstToken, Direction, SyntaxElement, SyntaxNode, SyntaxNodePtr, SyntaxToken,

TextSize, T,

};

db::HirDatabase,

semantics::source_to_def::{ChildContainer, SourceToDefCache, SourceToDefCtx},

source_analyzer::{resolve_hir_path, SourceAnalyzer},

};

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

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

let src = InFile::new(file_id, attr.clone());

self.with_ctx(|ctx| {

Some(res.to_vec())

})

}

let tt = derive.token_tree()?;

let file = self.find_file(derive.syntax());

let adt = derive.syntax().parent().and_then(ast::Adt::cast)?;

let res = self.with_ctx(|ctx| {

file.with_value(&adt),

file.with_value(derive.clone()),

)?;

let derive_idx = tt

.syntax()

(crate::Local, ast::SelfParam, self_param_to_def),

(crate::Label, ast::Label, label_to_def),

(crate::Adt, ast::Adt, adt_to_def),

];

fn find_root(node: &SyntaxNode) -> SyntaxNode {

use base_db::FileId;

use hir_def::{

child_by_source::ChildBySource,

dyn_map::DynMap,

expr::{LabelId, PatId},

ast::Adt::Union(it) => self.union_to_def(InFile::new(file_id, it)).map(AdtId::UnionId),

}

}

pub(super) fn bind_pat_to_def(

&mut self,

src: InFile<ast::IdentPat>,

pub(super) fn item_to_macro_call(&mut self, src: InFile<ast::Item>) -> Option<MacroCallId> {

let map = self.dyn_map(src.as_ref())?;

}

pub(super) fn attr_to_derive_macro_call(

&mut self,

item: InFile<&ast::Adt>,

src: InFile<ast::Attr>,

let map = self.dyn_map(item)?;

}

fn to_def<Ast: AstNode + 'static, ID: Copy + 'static>(

}

pub(super) fn macro_to_def(&mut self, src: InFile<ast::Macro>) -> Option<MacroDefId> {

if let res @ Some(_) = makro {

return res;

}

use either::Either;

use hir_expand::HirFileId;

use crate::{

db::DefDatabase,

// FIXME: Do we need to add proc-macros into a PROCMACRO dynmap here?

Either::Right(_fn) => return,

};

}

});

self.unnamed_consts().for_each(|konst| {

self.impls().for_each(|imp| add_impl(db, file_id, res, imp));

self.attr_macro_invocs().for_each(|(ast_id, call_id)| {

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

});

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

for (attr_id, calls) in calls {

}

}

});

/// 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:

}

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

pub(crate) fn set_derive_macro_invoc(

&mut self,

call: MacroCallId,

attr_id: AttrId,

idx: usize,

) {

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

invocs[idx] = Some(call);

}

/// independent of their indices.

pub(crate) fn init_derive_attribute(

&mut self,

attr_id: AttrId,

len: usize,

) {

}

pub(crate) fn derive_macro_invocs(

&self,

) -> impl Iterator<

> + '_ {

self.derive_macros

.iter()

use syntax::{ast, AstNode, AstPtr};

use crate::{

dyn_map::{DynMap, Policy},

ConstId, ConstParamId, EnumId, EnumVariantId, FieldId, FunctionId, ImplId, LifetimeParamId,

StaticId, StructId, TraitId, TypeAliasId, TypeParamId, UnionId,

pub const LIFETIME_PARAM: Key<ast::LifetimeParam, LifetimeParamId> = Key::new();

pub const CONST_PARAM: Key<ast::ConstParam, ConstParamId> = Key::new();

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

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

}

fn derive_macro_as_call_id(

derive_attr: AttrId,

db: &dyn db::DefDatabase,

krate: CrateId,

use base_db::{CrateId, Edition, FileId, ProcMacroId};

use cfg::{CfgExpr, CfgOptions};

use hir_expand::{

builtin_attr_macro::find_builtin_attr,

builtin_derive_macro::find_builtin_derive,

builtin_fn_macro::find_builtin_macro,

intern::Interned,

item_scope::{ImportType, PerNsGlobImports},

item_tree::{

},

macro_call_as_call_id,

nameres::{

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

enum MacroDirectiveKind {

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

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

}

) {

// Resolved to `#[derive]`

_ => {

let diag = DefDiagnostic::invalid_derive_target(

directive.module_id,

self.def_map.diagnostics.push(diag);

return recollect_without(self);

}

match attr.parse_path_comma_token_tree() {

Some(derive_macros) => {

if let Some(def) = def_map.exported_proc_macros.get(&loc.def) {

if let ProcMacroKind::CustomDerive { helpers } = &def.kind {

self.derive_helpers_in_scope

.or_default()

.extend(helpers.iter().cloned());

}

InvalidDeriveTarget { ast: AstId<ast::Item>, id: u32 },

}

#[derive(Debug, PartialEq, Eq)]

pub(super) fn malformed_derive(

container: LocalModuleId,

id: AttrId,

) -> Self {

Self {

expand_to: ExpandTo,

},

Derive {

derive_name: Box<str>,

/// Syntactical index of the invoking `#[derive]` attribute.

///

impl MacroCallKind {

/// Returns the file containing the macro invocation.

fn file_id(&self) -> HirFileId {

}

}

MacroCallKind::FnLike { ast_id, .. } => {

ast_id.with_value(ast_id.to_node(db).syntax().clone())

}

ast_id.with_value(ast_id.to_node(db).syntax().clone())

}

}

MacroCallKind::FnLike { ast_id, .. } => {

Some(ast_id.to_node(db).token_tree()?.syntax().clone())

}

}

}

.numeric_literal { color: #BFEBBF; }

.bool_literal { color: #BFE6EB; }

.macro { color: #94BFF3; }

.module { color: #AFD8AF; }

.value_param { color: #DCDCCC; }

.variable { color: #DCDCCC; }

.numeric_literal { color: #BFEBBF; }

.bool_literal { color: #BFE6EB; }

.macro { color: #94BFF3; }

.module { color: #AFD8AF; }

.value_param { color: #DCDCCC; }

.variable { color: #DCDCCC; }

.numeric_literal { color: #BFEBBF; }

.bool_literal { color: #BFE6EB; }

.macro { color: #94BFF3; }

.module { color: #AFD8AF; }

.value_param { color: #DCDCCC; }

.variable { color: #DCDCCC; }

.numeric_literal { color: #BFEBBF; }

.bool_literal { color: #BFE6EB; }

.macro { color: #94BFF3; }

.module { color: #AFD8AF; }

.value_param { color: #DCDCCC; }

.variable { color: #DCDCCC; }

.numeric_literal { color: #BFEBBF; }

.bool_literal { color: #BFE6EB; }

.macro { color: #94BFF3; }

.module { color: #AFD8AF; }

.value_param { color: #DCDCCC; }

.variable { color: #DCDCCC; }

.numeric_literal { color: #BFEBBF; }

.bool_literal { color: #BFE6EB; }

.macro { color: #94BFF3; }

.module { color: #AFD8AF; }

.value_param { color: #DCDCCC; }

.variable { color: #DCDCCC; }

.numeric_literal { color: #BFEBBF; }

.bool_literal { color: #BFE6EB; }

.macro { color: #94BFF3; }

.module { color: #AFD8AF; }

.value_param { color: #DCDCCC; }

.variable { color: #DCDCCC; }

.numeric_literal { color: #BFEBBF; }

.bool_literal { color: #BFE6EB; }

.macro { color: #94BFF3; }

.module { color: #AFD8AF; }

.value_param { color: #DCDCCC; }

.variable { color: #DCDCCC; }

.numeric_literal { color: #BFEBBF; }

.bool_literal { color: #BFE6EB; }

.macro { color: #94BFF3; }

.module { color: #AFD8AF; }

.value_param { color: #DCDCCC; }

.variable { color: #DCDCCC; }

.numeric_literal { color: #BFEBBF; }

.bool_literal { color: #BFE6EB; }

.macro { color: #94BFF3; }

.module { color: #AFD8AF; }

.value_param { color: #DCDCCC; }

.variable { color: #DCDCCC; }

<span class="brace">}</span>

<span class="keyword">use</span> <span class="self_keyword crate_root">self</span><span class="operator">::</span><span class="struct">FooCopy</span><span class="operator">::</span><span class="brace">{</span><span class="self_keyword">self</span> <span class="keyword">as</span> <span class="struct declaration">BarCopy</span><span class="brace">}</span><span class="semicolon">;</span>

<span class="attribute_bracket attribute">#</span><span class="attribute_bracket attribute">[</span><span class="attribute attribute default_library library">derive</span><span class="parenthesis attribute">(</span><span class="derive attribute default_library library">Copy</span><span class="parenthesis attribute">)</span><span class="attribute_bracket attribute">]</span>

<span class="keyword">struct</span> <span class="struct declaration">FooCopy</span> <span class="brace">{</span>

<span class="field declaration">x</span><span class="colon">:</span> <span class="builtin_type">u32</span><span class="comma">,</span>

<span class="brace">}</span>

.numeric_literal { color: #BFEBBF; }

.bool_literal { color: #BFE6EB; }

.macro { color: #94BFF3; }

.module { color: #AFD8AF; }

.value_param { color: #DCDCCC; }

.variable { color: #DCDCCC; }

.numeric_literal { color: #BFEBBF; }

.bool_literal { color: #BFE6EB; }

.macro { color: #94BFF3; }

.module { color: #AFD8AF; }

.value_param { color: #DCDCCC; }

.variable { color: #DCDCCC; }

}

use self::FooCopy::{self as BarCopy};

#[derive(Copy)]

struct FooCopy {

x: u32,

}