-use std::{fmt, hash::Hash, iter};

- span::{HirFileIdRepr, SyntaxContextId},

- algo::{self, skip_trivia_token},

- AstPtr, Direction, SyntaxNode, SyntaxNodePtr, SyntaxToken, TextSize,

- ast_id_map::{AstIdNode, ErasedFileAstId, FileAstId},

-pub type SpanMap = ::mbe::TokenMap<tt::SpanData>;

- pub(crate) krate: CrateId,

- let macro_file = self.macro_file()?;

- ExpansionInfo::new(db, macro_file)

- let id = match self.kind {

- | MacroDefKind::BuiltInEager(_, id) => id,

- };

- Either::Left(id)

- MacroCallKind::Attr { .. } if self.def.is_attribute_derive() => ExpandTo::Statements,

- // is this always correct?

-// FIXME: attribute indices do not account for nested `cfg_attr`

-

- fn arg(&self, db: &dyn db::ExpandDatabase) -> Option<InFile<SyntaxNode>> {

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

- .to_in_file_node(db)

- .map(|it| Some(it.token_tree()?.syntax().clone()))

- .transpose(),

- Some(ast_id.to_in_file_node(db).syntax().cloned())

- Some(ast_id.to_in_file_node(db).syntax().cloned())

- expanded: InMacroFile<SyntaxNode>,

- arg: InFile<SyntaxNode>,

- exp_map: Arc<SpanMap>,

- Some(self.arg.with_value(self.arg.value.parent()?))

- /// Map a token down from macro input into the macro expansion.

- ///

- /// The inner workings of this function differ slightly depending on the type of macro we are dealing with:

- /// - declarative:

- /// For declarative macros, we need to accommodate for the macro definition site(which acts as a second unchanging input)

- /// , as tokens can mapped in and out of it.

- /// To do this we shift all ids in the expansion by the maximum id of the definition site giving us an easy

- /// way to map all the tokens.

- /// - attribute:

- /// Attributes have two different inputs, the input tokentree in the attribute node and the item

- /// the attribute is annotating. Similarly as for declarative macros we need to do a shift here

- /// as well. Currently this is done by shifting the attribute input by the maximum id of the item.

- /// - function-like and derives:

- /// Both of these only have one simple call site input so no special handling is required here.

- pub fn map_token_down(

- &self,

- db: &dyn db::ExpandDatabase,

- token: InFile<&SyntaxToken>,

- ) -> Option<impl Iterator<Item = InFile<SyntaxToken>> + '_> {

- assert_eq!(token.file_id, self.arg.file_id);

- .map_or(false, |(_, span)| span.anchor.file_id == token.file_id)

- (0, span_map.partition_point(|a| a.1.anchor.file_id == token.file_id))

- let start = span_map.partition_point(|a| a.1.anchor.file_id != token.file_id);

- (

- start,

- start + span_map[start..].partition_point(|a| a.1.anchor.file_id == token.file_id),

- )

- let token_text_range = token.value.text_range();

- let ast_id_map = db.ast_id_map(token.file_id);

- let offset = ast_id_map.get_raw(span.anchor.ast_id).text_range().start();

- token_text_range.eq(&abs_range).then_some(*range)

- /// Map a token up out of the expansion it resides in into the arguments of the macro call of the expansion.

- pub fn map_token_up(

- token: InFile<&SyntaxToken>,

- ) -> Option<InFile<SyntaxToken>> {

- self.exp_map.span_for_range(token.value.text_range()).and_then(|span| {

- let anchor =

- db.ast_id_map(span.anchor.file_id).get_raw(span.anchor.ast_id).text_range().start();

- InFile::new(

- span.anchor.file_id,

- db.parse_or_expand(span.anchor.file_id)

- .covering_element(span.range + anchor)

- .into_token(),

- )

- .transpose()

- })

- fn new(db: &dyn db::ExpandDatabase, macro_file: MacroFile) -> Option<ExpansionInfo> {

- let arg_tt = loc.kind.arg(db)?;

- Some(ExpansionInfo {

- })

- }

-}

-

-/// `AstId` points to an AST node in any file.

-///

-/// It is stable across reparses, and can be used as salsa key/value.

-pub type AstId<N> = InFile<FileAstId<N>>;

-

-impl<N: AstIdNode> AstId<N> {

- pub fn to_node(&self, db: &dyn db::ExpandDatabase) -> N {

- self.to_ptr(db).to_node(&db.parse_or_expand(self.file_id))

- }

- pub fn to_in_file_node(&self, db: &dyn db::ExpandDatabase) -> InFile<N> {

- InFile::new(self.file_id, self.to_ptr(db).to_node(&db.parse_or_expand(self.file_id)))

- }

- pub fn to_ptr(&self, db: &dyn db::ExpandDatabase) -> AstPtr<N> {

- db.ast_id_map(self.file_id).get(self.value)

- }

-}

-

-pub type ErasedAstId = InFile<ErasedFileAstId>;

-

-impl ErasedAstId {

- pub fn to_ptr(&self, db: &dyn db::ExpandDatabase) -> SyntaxNodePtr {

- db.ast_id_map(self.file_id).get_raw(self.value)

- }

-}

-

-/// `InFile<T>` stores a value of `T` inside a particular file/syntax tree.

-///

-/// Typical usages are:

-///

-/// * `InFile<SyntaxNode>` -- syntax node in a file

-/// * `InFile<ast::FnDef>` -- ast node in a file

-/// * `InFile<TextSize>` -- offset in a file

-#[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]

-pub struct InFile<T> {

- pub file_id: HirFileId,

- pub value: T,

-}

-

-impl<T> InFile<T> {

- pub fn new(file_id: HirFileId, value: T) -> InFile<T> {

- InFile { file_id, value }

- }

-

- pub fn with_value<U>(&self, value: U) -> InFile<U> {

- InFile::new(self.file_id, value)

- }

-

- pub fn map<F: FnOnce(T) -> U, U>(self, f: F) -> InFile<U> {

- InFile::new(self.file_id, f(self.value))

- }

-

- pub fn as_ref(&self) -> InFile<&T> {

- self.with_value(&self.value)

- }

-

- pub fn file_syntax(&self, db: &dyn db::ExpandDatabase) -> SyntaxNode {

- db.parse_or_expand(self.file_id)

- }

-}

-

-impl<T: Clone> InFile<&T> {

- pub fn cloned(&self) -> InFile<T> {

- self.with_value(self.value.clone())

- }

-}

-

-impl<T> InFile<Option<T>> {

- pub fn transpose(self) -> Option<InFile<T>> {

- let value = self.value?;

- Some(InFile::new(self.file_id, value))

- }

-}

-

-impl<L, R> InFile<Either<L, R>> {

- pub fn transpose(self) -> Either<InFile<L>, InFile<R>> {

- match self.value {

- Either::Left(l) => Either::Left(InFile::new(self.file_id, l)),

- Either::Right(r) => Either::Right(InFile::new(self.file_id, r)),

-impl InFile<&SyntaxNode> {

- pub fn ancestors_with_macros(

- self,

- db: &dyn db::ExpandDatabase,

- ) -> impl Iterator<Item = InFile<SyntaxNode>> + Clone + '_ {

- iter::successors(Some(self.cloned()), move |node| match node.value.parent() {

- Some(parent) => Some(node.with_value(parent)),

- None => node.file_id.call_node(db),

- })

- }

-

- /// Skips the attributed item that caused the macro invocation we are climbing up

- pub fn ancestors_with_macros_skip_attr_item(

- self,

- db: &dyn db::ExpandDatabase,

- ) -> impl Iterator<Item = InFile<SyntaxNode>> + '_ {

- let succ = move |node: &InFile<SyntaxNode>| match node.value.parent() {

- Some(parent) => Some(node.with_value(parent)),

- None => {

- let parent_node = node.file_id.call_node(db)?;

- if node.file_id.is_attr_macro(db) {

- // macro call was an attributed item, skip it

- // FIXME: does this fail if this is a direct expansion of another macro?

- parent_node.map(|node| node.parent()).transpose()

- } else {

- Some(parent_node)

- }

- }

- };

- iter::successors(succ(&self.cloned()), succ)

- }

-

- /// Falls back to the macro call range if the node cannot be mapped up fully.

- ///

- /// For attributes and derives, this will point back to the attribute only.

- /// For the entire item use [`InFile::original_file_range_full`].

- pub fn original_file_range(self, db: &dyn db::ExpandDatabase) -> FileRange {

- match self.file_id.repr() {

- HirFileIdRepr::FileId(file_id) => FileRange { file_id, range: self.value.text_range() },

- HirFileIdRepr::MacroFile(mac_file) => {

- if let Some(res) = self.original_file_range_opt(db) {

- return res;

- }

- // Fall back to whole macro call.

- let loc = db.lookup_intern_macro_call(mac_file.macro_call_id);

- loc.kind.original_call_range(db)

- }

- }

- }

-

- /// Falls back to the macro call range if the node cannot be mapped up fully.

- pub fn original_file_range_full(self, db: &dyn db::ExpandDatabase) -> FileRange {

- match self.file_id.repr() {

- HirFileIdRepr::FileId(file_id) => FileRange { file_id, range: self.value.text_range() },

- HirFileIdRepr::MacroFile(mac_file) => {

- if let Some(res) = self.original_file_range_opt(db) {

- return res;

- }

- // Fall back to whole macro call.

- let loc = db.lookup_intern_macro_call(mac_file.macro_call_id);

- loc.kind.original_call_range_with_body(db)

- }

- }

- }

-

- /// Attempts to map the syntax node back up its macro calls.

- pub fn original_file_range_opt(self, db: &dyn db::ExpandDatabase) -> Option<FileRange> {

- match ascend_node_border_tokens(db, self) {

- Some(InFile { file_id, value: (first, last) }) => {

- let original_file = file_id.original_file(db);

- let range = first.text_range().cover(last.text_range());

- if file_id != original_file.into() {

- tracing::error!("Failed mapping up more for {:?}", range);

- return None;

- }

- Some(FileRange { file_id: original_file, range })

- }

- _ if !self.file_id.is_macro() => Some(FileRange {

- file_id: self.file_id.original_file(db),

- range: self.value.text_range(),

- }),

- _ => None,

- }

- }

-

- pub fn original_syntax_node(self, db: &dyn db::ExpandDatabase) -> Option<InFile<SyntaxNode>> {

- // This kind of upmapping can only be achieved in attribute expanded files,

- // as we don't have node inputs otherwise and therefore can't find an `N` node in the input

- if !self.file_id.is_macro() {

- return Some(self.map(Clone::clone));

- } else if !self.file_id.is_attr_macro(db) {

- return None;

- }

-

- if let Some(InFile { file_id, value: (first, last) }) = ascend_node_border_tokens(db, self)

- {

- if file_id.is_macro() {

- let range = first.text_range().cover(last.text_range());

- tracing::error!("Failed mapping out of macro file for {:?}", range);

- return None;

- }

- // FIXME: This heuristic is brittle and with the right macro may select completely unrelated nodes

- let anc = algo::least_common_ancestor(&first.parent()?, &last.parent()?)?;

- let kind = self.value.kind();

- let value = anc.ancestors().find(|it| it.kind() == kind)?;

- return Some(InFile::new(file_id, value));

- }

- None

- }

-}

-

-impl InFile<SyntaxToken> {

- pub fn upmap(self, db: &dyn db::ExpandDatabase) -> Option<InFile<SyntaxToken>> {

- let expansion = self.file_id.expansion_info(db)?;

- expansion.map_token_up(db, self.as_ref())

- }

-

- /// Falls back to the macro call range if the node cannot be mapped up fully.

- pub fn original_file_range(self, db: &dyn db::ExpandDatabase) -> FileRange {

- match self.file_id.repr() {

- HirFileIdRepr::FileId(file_id) => FileRange { file_id, range: self.value.text_range() },

- HirFileIdRepr::MacroFile(mac_file) => {

- if let Some(res) = self.original_file_range_opt(db) {

- return res;

- }

- // Fall back to whole macro call.

- let loc = db.lookup_intern_macro_call(mac_file.macro_call_id);

- loc.kind.original_call_range(db)

- }

- }

- }

-

- /// Attempts to map the syntax node back up its macro calls.

- pub fn original_file_range_opt(self, db: &dyn db::ExpandDatabase) -> Option<FileRange> {

- match self.file_id.repr() {

- HirFileIdRepr::FileId(file_id) => {

- Some(FileRange { file_id, range: self.value.text_range() })

- }

- HirFileIdRepr::MacroFile(_) => {

- let expansion = self.file_id.expansion_info(db)?;

- let InFile { file_id, value } = ascend_call_token(db, &expansion, self)?;

- let original_file = file_id.original_file(db);

- if file_id != original_file.into() {

- return None;

- }

- Some(FileRange { file_id: original_file, range: value.text_range() })

- }

- }

- }

-}

-

-#[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]

-pub struct InMacroFile<T> {

- pub file_id: MacroFile,

- pub value: T,

-}

-

-impl<T> From<InMacroFile<T>> for InFile<T> {

- fn from(macro_file: InMacroFile<T>) -> Self {

- InFile { file_id: macro_file.file_id.into(), value: macro_file.value }

- }

-}

-

-// FIXME: Get rid of this

-fn ascend_node_border_tokens(

- db: &dyn db::ExpandDatabase,

- InFile { file_id, value: node }: InFile<&SyntaxNode>,

-) -> Option<InFile<(SyntaxToken, SyntaxToken)>> {

- let expansion = file_id.expansion_info(db)?;

-

- let first_token = |node: &SyntaxNode| skip_trivia_token(node.first_token()?, Direction::Next);

- let last_token = |node: &SyntaxNode| skip_trivia_token(node.last_token()?, Direction::Prev);

-

- // FIXME: Once the token map rewrite is done, this shouldnt need to rely on syntax nodes and tokens anymore

- let first = first_token(node)?;

- let last = last_token(node)?;

- let first = ascend_call_token(db, &expansion, InFile::new(file_id, first))?;

- let last = ascend_call_token(db, &expansion, InFile::new(file_id, last))?;

- (first.file_id == last.file_id).then(|| InFile::new(first.file_id, (first.value, last.value)))

-}

-

-fn ascend_call_token(

- db: &dyn db::ExpandDatabase,

- expansion: &ExpansionInfo,

- token: InFile<SyntaxToken>,

-) -> Option<InFile<SyntaxToken>> {

- let mut mapping = expansion.map_token_up(db, token.as_ref())?;

-

- loop {

- match mapping.file_id.expansion_info(db) {

- Some(info) => mapping = info.map_token_up(db, mapping.as_ref())?,

- None => return Some(mapping),

- }

- }

-}

-

-impl<N: AstNode> InFile<N> {

- pub fn descendants<T: AstNode>(self) -> impl Iterator<Item = InFile<T>> {

- self.value.syntax().descendants().filter_map(T::cast).map(move |n| self.with_value(n))

- }

-

- // FIXME: this should return `Option<InFileNotHirFile<N>>`

- pub fn original_ast_node(self, db: &dyn db::ExpandDatabase) -> Option<InFile<N>> {

- // This kind of upmapping can only be achieved in attribute expanded files,

- // as we don't have node inputs otherwise and therefore can't find an `N` node in the input

- if !self.file_id.is_macro() {

- return Some(self);

- } else if !self.file_id.is_attr_macro(db) {

- return None;

- }

-

- if let Some(InFile { file_id, value: (first, last) }) =

- ascend_node_border_tokens(db, self.syntax())

- {

- if file_id.is_macro() {

- let range = first.text_range().cover(last.text_range());

- tracing::error!("Failed mapping out of macro file for {:?}", range);

- return None;

- }

- // FIXME: This heuristic is brittle and with the right macro may select completely unrelated nodes

- let anc = algo::least_common_ancestor(&first.parent()?, &last.parent()?)?;

- let value = anc.ancestors().find_map(N::cast)?;

- return Some(InFile::new(file_id, value));

- }

- None

- }

-

- pub fn syntax(&self) -> InFile<&SyntaxNode> {

- self.with_value(self.value.syntax())

- }

-}

-

-#[derive(Debug)]

-pub struct UnresolvedMacro {

- pub path: ModPath,

-}

-